| #!/usr/bin/env python3 |
| # Copyright 2016 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 shlex |
| import subprocess |
| import re, json |
| import tempfile |
| import pathlib |
| import unittest, os, sys, shutil, time |
| from glob import glob |
| import mesonbuild.compilers |
| import mesonbuild.environment |
| import mesonbuild.mesonlib |
| from mesonbuild.environment import detect_ninja, Environment |
| from mesonbuild.dependencies import PkgConfigDependency |
| |
| def get_soname(fname): |
| # HACK, fix to not use shell. |
| raw_out = subprocess.check_output(['readelf', '-a', fname], |
| universal_newlines=True) |
| pattern = re.compile('soname: \[(.*?)\]') |
| for line in raw_out.split('\n'): |
| m = pattern.search(line) |
| if m is not None: |
| return m.group(1) |
| raise RuntimeError('Could not determine soname:\n\n' + raw_out) |
| |
| def get_fake_options(prefix): |
| import argparse |
| opts = argparse.Namespace() |
| opts.cross_file = None |
| opts.prefix = prefix |
| return opts |
| |
| class FakeEnvironment(object): |
| def __init__(self): |
| self.cross_info = None |
| |
| def is_cross_build(self): |
| return False |
| |
| class InternalTests(unittest.TestCase): |
| |
| def test_version_number(self): |
| searchfunc = mesonbuild.environment.search_version |
| self.assertEqual(searchfunc('foobar 1.2.3'), '1.2.3') |
| self.assertEqual(searchfunc('1.2.3'), '1.2.3') |
| self.assertEqual(searchfunc('foobar 2016.10.28 1.2.3'), '1.2.3') |
| self.assertEqual(searchfunc('2016.10.28 1.2.3'), '1.2.3') |
| self.assertEqual(searchfunc('foobar 2016.10.128'), 'unknown version') |
| self.assertEqual(searchfunc('2016.10.128'), 'unknown version') |
| |
| def test_mode_symbolic_to_bits(self): |
| modefunc = mesonbuild.mesonlib.FileMode.perms_s_to_bits |
| self.assertEqual(modefunc('---------'), 0) |
| self.assertEqual(modefunc('r--------'), stat.S_IRUSR) |
| self.assertEqual(modefunc('---r-----'), stat.S_IRGRP) |
| self.assertEqual(modefunc('------r--'), stat.S_IROTH) |
| self.assertEqual(modefunc('-w-------'), stat.S_IWUSR) |
| self.assertEqual(modefunc('----w----'), stat.S_IWGRP) |
| self.assertEqual(modefunc('-------w-'), stat.S_IWOTH) |
| self.assertEqual(modefunc('--x------'), stat.S_IXUSR) |
| self.assertEqual(modefunc('-----x---'), stat.S_IXGRP) |
| self.assertEqual(modefunc('--------x'), stat.S_IXOTH) |
| self.assertEqual(modefunc('--S------'), stat.S_ISUID) |
| self.assertEqual(modefunc('-----S---'), stat.S_ISGID) |
| self.assertEqual(modefunc('--------T'), stat.S_ISVTX) |
| self.assertEqual(modefunc('--s------'), stat.S_ISUID | stat.S_IXUSR) |
| self.assertEqual(modefunc('-----s---'), stat.S_ISGID | stat.S_IXGRP) |
| self.assertEqual(modefunc('--------t'), stat.S_ISVTX | stat.S_IXOTH) |
| self.assertEqual(modefunc('rwx------'), stat.S_IRWXU) |
| self.assertEqual(modefunc('---rwx---'), stat.S_IRWXG) |
| self.assertEqual(modefunc('------rwx'), stat.S_IRWXO) |
| # We could keep listing combinations exhaustively but that seems |
| # tedious and pointless. Just test a few more. |
| self.assertEqual(modefunc('rwxr-xr-x'), |
| stat.S_IRWXU | |
| stat.S_IRGRP | stat.S_IXGRP | |
| stat.S_IROTH | stat.S_IXOTH) |
| self.assertEqual(modefunc('rw-r--r--'), |
| stat.S_IRUSR | stat.S_IWUSR | |
| stat.S_IRGRP | |
| stat.S_IROTH) |
| self.assertEqual(modefunc('rwsr-x---'), |
| stat.S_IRWXU | stat.S_ISUID | |
| stat.S_IRGRP | stat.S_IXGRP) |
| |
| def test_compiler_args_class(self): |
| cargsfunc = mesonbuild.compilers.CompilerArgs |
| c = mesonbuild.environment.CCompiler([], 'fake', False) |
| # Test that bad initialization fails |
| self.assertRaises(TypeError, cargsfunc, []) |
| self.assertRaises(TypeError, cargsfunc, [], []) |
| self.assertRaises(TypeError, cargsfunc, c, [], []) |
| # Test that empty initialization works |
| a = cargsfunc(c) |
| self.assertEqual(a, []) |
| # Test that list initialization works |
| a = cargsfunc(['-I.', '-I..'], c) |
| self.assertEqual(a, ['-I.', '-I..']) |
| # Test that there is no de-dup on initialization |
| self.assertEqual(cargsfunc(['-I.', '-I.'], c), ['-I.', '-I.']) |
| |
| ## Test that appending works |
| a.append('-I..') |
| self.assertEqual(a, ['-I..', '-I.']) |
| a.append('-O3') |
| self.assertEqual(a, ['-I..', '-I.', '-O3']) |
| |
| ## Test that in-place addition works |
| a += ['-O2', '-O2'] |
| self.assertEqual(a, ['-I..', '-I.', '-O3', '-O2', '-O2']) |
| # Test that removal works |
| a.remove('-O2') |
| self.assertEqual(a, ['-I..', '-I.', '-O3', '-O2']) |
| # Test that de-dup happens on addition |
| a += ['-Ifoo', '-Ifoo'] |
| self.assertEqual(a, ['-Ifoo', '-I..', '-I.', '-O3', '-O2']) |
| |
| # .extend() is just +=, so we don't test it |
| |
| ## Test that addition works |
| # Test that adding a list with just one old arg works and yields the same array |
| a = a + ['-Ifoo'] |
| self.assertEqual(a, ['-Ifoo', '-I..', '-I.', '-O3', '-O2']) |
| # Test that adding a list with one arg new and one old works |
| a = a + ['-Ifoo', '-Ibaz'] |
| self.assertEqual(a, ['-Ifoo', '-Ibaz', '-I..', '-I.', '-O3', '-O2']) |
| # Test that adding args that must be prepended and appended works |
| a = a + ['-Ibar', '-Wall'] |
| self.assertEqual(a, ['-Ibar', '-Ifoo', '-Ibaz', '-I..', '-I.', '-O3', '-O2', '-Wall']) |
| |
| ## Test that reflected addition works |
| # Test that adding to a list with just one old arg works and DOES NOT yield the same array |
| a = ['-Ifoo'] + a |
| self.assertEqual(a, ['-Ibar', '-Ifoo', '-Ibaz', '-I..', '-I.', '-O3', '-O2', '-Wall']) |
| # Test that adding to a list with just one new arg that is not pre-pended works |
| a = ['-Werror'] + a |
| self.assertEqual(a, ['-Ibar', '-Ifoo', '-Ibaz', '-I..', '-I.', '-Werror', '-O3', '-O2', '-Wall']) |
| # Test that adding to a list with two new args preserves the order |
| a = ['-Ldir', '-Lbah'] + a |
| self.assertEqual(a, ['-Ibar', '-Ifoo', '-Ibaz', '-I..', '-I.', '-Ldir', '-Lbah', '-Werror', '-O3', '-O2', '-Wall']) |
| |
| def test_commonpath(self): |
| from os.path import sep |
| commonpath = mesonbuild.mesonlib.commonpath |
| self.assertRaises(ValueError, commonpath, []) |
| self.assertEqual(commonpath(['/usr', '/usr']), sep + 'usr') |
| self.assertEqual(commonpath(['/usr', '/usr/']), sep + 'usr') |
| self.assertEqual(commonpath(['/usr', '/usr/bin']), sep + 'usr') |
| self.assertEqual(commonpath(['/usr/', '/usr/bin']), sep + 'usr') |
| self.assertEqual(commonpath(['/usr/./', '/usr/bin']), sep + 'usr') |
| self.assertEqual(commonpath(['/usr/bin', '/usr/bin']), sep + 'usr' + sep + 'bin') |
| self.assertEqual(commonpath(['/usr//bin', '/usr/bin']), sep + 'usr' + sep + 'bin') |
| self.assertEqual(commonpath(['/usr/./bin', '/usr/bin']), sep + 'usr' + sep + 'bin') |
| self.assertEqual(commonpath(['/usr/local', '/usr/lib']), sep + 'usr') |
| self.assertEqual(commonpath(['/usr', '/bin']), sep) |
| self.assertEqual(commonpath(['/usr', 'bin']), '') |
| self.assertEqual(commonpath(['blam', 'bin']), '') |
| prefix = '/some/path/to/prefix' |
| libdir = '/some/path/to/prefix/libdir' |
| self.assertEqual(commonpath([prefix, libdir]), str(pathlib.PurePath(prefix))) |
| |
| |
| class LinuxlikeTests(unittest.TestCase): |
| def setUp(self): |
| super().setUp() |
| src_root = os.path.dirname(__file__) |
| src_root = os.path.join(os.getcwd(), src_root) |
| self.builddir = tempfile.mkdtemp() |
| self.logdir = os.path.join(self.builddir, 'meson-logs') |
| self.prefix = '/usr' |
| self.libdir = os.path.join(self.prefix, 'lib') |
| self.installdir = os.path.join(self.builddir, 'install') |
| self.meson_command = [sys.executable, os.path.join(src_root, 'meson.py')] |
| self.mconf_command = [sys.executable, os.path.join(src_root, 'mesonconf.py')] |
| self.mintro_command = [sys.executable, os.path.join(src_root, 'mesonintrospect.py')] |
| self.mtest_command = [sys.executable, os.path.join(src_root, 'mesontest.py'), '-C', self.builddir] |
| self.ninja_command = [detect_ninja(), '-C', self.builddir] |
| self.common_test_dir = os.path.join(src_root, 'test cases/common') |
| self.vala_test_dir = os.path.join(src_root, 'test cases/vala') |
| self.framework_test_dir = os.path.join(src_root, 'test cases/frameworks') |
| self.unit_test_dir = os.path.join(src_root, 'test cases/unit') |
| self.output = b'' |
| self.orig_env = os.environ.copy() |
| |
| def tearDown(self): |
| shutil.rmtree(self.builddir) |
| os.environ = self.orig_env |
| super().tearDown() |
| |
| def _run(self, command): |
| self.output += subprocess.check_output(command, stderr=subprocess.STDOUT, |
| env=os.environ.copy()) |
| |
| def init(self, srcdir, extra_args=None): |
| if extra_args is None: |
| extra_args = [] |
| args = [srcdir, self.builddir, |
| '--prefix', self.prefix, |
| '--libdir', self.libdir] |
| self._run(self.meson_command + args + extra_args) |
| self.privatedir = os.path.join(self.builddir, 'meson-private') |
| |
| def build(self): |
| self._run(self.ninja_command) |
| |
| def run_tests(self): |
| self._run(self.ninja_command + ['test']) |
| |
| def install(self): |
| os.environ['DESTDIR'] = self.installdir |
| self._run(self.ninja_command + ['install']) |
| |
| def uninstall(self): |
| self._run(self.ninja_command + ['uninstall']) |
| |
| def run_target(self, target): |
| self.output += subprocess.check_output(self.ninja_command + [target]) |
| |
| def setconf(self, arg): |
| self._run(self.mconf_command + [arg, self.builddir]) |
| |
| def wipe(self): |
| shutil.rmtree(self.builddir) |
| |
| def get_compdb(self): |
| with open(os.path.join(self.builddir, 'compile_commands.json')) as ifile: |
| return json.load(ifile) |
| |
| def get_meson_log(self): |
| with open(os.path.join(self.builddir, 'meson-logs', 'meson-log.txt')) as f: |
| return f.readlines() |
| |
| def get_meson_log_compiler_checks(self): |
| ''' |
| Fetch a list command-lines run by meson for compiler checks. |
| Each command-line is returned as a list of arguments. |
| ''' |
| log = self.get_meson_log() |
| prefix = 'Command line:' |
| cmds = [l[len(prefix):].split() for l in log if l.startswith(prefix)] |
| return cmds |
| |
| def introspect(self, arg): |
| out = subprocess.check_output(self.mintro_command + [arg, self.builddir], |
| universal_newlines=True) |
| return json.loads(out) |
| |
| 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, '27 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. |
| ''' |
| testdir = os.path.join(self.common_test_dir, '3 static') |
| self.init(testdir) |
| compdb = self.get_compdb() |
| self.assertIn('-fPIC', compdb[0]['command']) |
| # This is needed to increase the difference between build.ninja's |
| # timestamp and coredata.dat's timestamp due to a Ninja bug. |
| # https://github.com/ninja-build/ninja/issues/371 |
| time.sleep(1) |
| self.setconf('-Db_staticpic=false') |
| # Regenerate build |
| self.build() |
| compdb = self.get_compdb() |
| self.assertNotIn('-fPIC', compdb[0]['command']) |
| |
| 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, '51 pkgconfig-gen') |
| self.init(testdir) |
| env = FakeEnvironment() |
| kwargs = {'required': True, 'silent': True} |
| os.environ['PKG_CONFIG_LIBDIR'] = self.privatedir |
| simple_dep = PkgConfigDependency('libfoo', env, kwargs) |
| self.assertTrue(simple_dep.found()) |
| self.assertEqual(simple_dep.get_version(), '1.0') |
| self.assertIn('-lfoo', simple_dep.get_link_args()) |
| |
| 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 |
| ''' |
| 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('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) |
| |
| def test_static_compile_order(self): |
| ''' |
| Test that the order of files in a compiler command-line while compiling |
| and linking statically is deterministic. This can't be an ordinary test |
| case because we need to inspect the compiler database. |
| https://github.com/mesonbuild/meson/pull/951 |
| ''' |
| testdir = os.path.join(self.common_test_dir, '5 linkstatic') |
| self.init(testdir) |
| compdb = self.get_compdb() |
| # Rules will get written out in this order |
| self.assertTrue(compdb[0]['file'].endswith("libfile.c")) |
| self.assertTrue(compdb[1]['file'].endswith("libfile2.c")) |
| self.assertTrue(compdb[2]['file'].endswith("libfile3.c")) |
| self.assertTrue(compdb[3]['file'].endswith("libfile4.c")) |
| # FIXME: We don't have access to the linker command |
| |
| def test_install_introspection(self): |
| ''' |
| Tests that the Meson introspection API exposes install filenames correctly |
| https://github.com/mesonbuild/meson/issues/829 |
| ''' |
| testdir = os.path.join(self.common_test_dir, '8 install') |
| self.init(testdir) |
| intro = self.introspect('--targets') |
| if intro[0]['type'] == 'executable': |
| intro = intro[::-1] |
| self.assertEqual(intro[0]['install_filename'], '/usr/lib/libstat.a') |
| self.assertEqual(intro[1]['install_filename'], '/usr/bin/prog') |
| |
| def test_run_target_files_path(self): |
| ''' |
| Test that run_targets are run from the correct directory |
| https://github.com/mesonbuild/meson/issues/957 |
| ''' |
| testdir = os.path.join(self.common_test_dir, '58 run target') |
| self.init(testdir) |
| self.run_target('check_exists') |
| |
| 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 unittest.SkipTest('QMake not found') |
| # For some inexplicable reason qmake --version gives different |
| # results when run from the command line vs invoked by Python. |
| # Check for both cases in case this behaviour changes in the future. |
| output = subprocess.getoutput(['qmake', '--version']) |
| if 'Qt version 5' not in output and 'qt5' not in output: |
| raise unittest.SkipTest('Qmake found, but it is not for Qt 5.') |
| # Disable pkg-config codepath and force searching with qmake/qmake-qt5 |
| os.environ['PKG_CONFIG_LIBDIR'] = self.builddir |
| os.environ['PKG_CONFIG_PATH'] = self.builddir |
| testdir = os.path.join(self.framework_test_dir, '4 qt') |
| self.init(testdir) |
| # Confirm that the dependency was found with qmake |
| msg = 'Qt5 native `qmake-qt5` dependency (modules: Core) found: YES\n' |
| msg2 = 'Qt5 native `qmake` dependency (modules: Core) found: YES\n' |
| mesonlog = self.get_meson_log() |
| self.assertTrue(msg in mesonlog or msg2 in mesonlog) |
| |
| def get_soname(self, fname): |
| output = subprocess.check_output(['readelf', '-a', fname], |
| universal_newlines=True) |
| for line in output.split('\n'): |
| if 'SONAME' in line: |
| return line.split('[')[1].split(']')[0] |
| raise RuntimeError('Readelf gave no SONAME.') |
| |
| def _test_soname_impl(self, libpath, install): |
| 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.assertTrue(os.path.exists(nover)) |
| self.assertFalse(os.path.islink(nover)) |
| self.assertEqual(self.get_soname(nover), 'libnover.so') |
| self.assertEqual(len(glob(nover[:-3] + '*')), 1) |
| |
| # File with version set |
| verset = os.path.join(libpath, 'libverset.so') |
| self.assertTrue(os.path.exists(verset + '.4.5.6')) |
| self.assertEqual(os.readlink(verset), 'libverset.so.4') |
| self.assertEqual(self.get_soname(verset), 'libverset.so.4') |
| self.assertEqual(len(glob(verset[:-3] + '*')), 3) |
| |
| # File with soversion set |
| soverset = os.path.join(libpath, 'libsoverset.so') |
| self.assertTrue(os.path.exists(soverset + '.1.2.3')) |
| self.assertEqual(os.readlink(soverset), 'libsoverset.so.1.2.3') |
| self.assertEqual(self.get_soname(soverset), 'libsoverset.so.1.2.3') |
| self.assertEqual(len(glob(soverset[:-3] + '*')), 2) |
| |
| # File with version and soversion set to same values |
| settosame = os.path.join(libpath, 'libsettosame.so') |
| self.assertTrue(os.path.exists(settosame + '.7.8.9')) |
| self.assertEqual(os.readlink(settosame), 'libsettosame.so.7.8.9') |
| self.assertEqual(self.get_soname(settosame), 'libsettosame.so.7.8.9') |
| self.assertEqual(len(glob(settosame[:-3] + '*')), 2) |
| |
| # File with version and soversion set to different values |
| bothset = os.path.join(libpath, 'libbothset.so') |
| self.assertTrue(os.path.exists(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(self.get_soname(bothset), 'libbothset.so.1.2.3') |
| self.assertEqual(len(glob(bothset[:-3] + '*')), 3) |
| |
| def test_soname(self): |
| self._test_soname_impl(self.builddir, False) |
| |
| def test_installed_soname(self): |
| self._test_soname_impl(self.installdir + self.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. |
| ''' |
| Oflag = '-O3' |
| os.environ['CFLAGS'] = os.environ['CXXFLAGS'] = Oflag |
| testdir = os.path.join(self.common_test_dir, '43 has function') |
| self.init(testdir) |
| 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 '43 has function' test case |
| self.assertEqual(cmd[1], '-I/tmp') |
| # Verify that -O3 set via the environment is overriden by -O0 |
| Oargs = [arg for arg in cmd if arg.startswith('-O')] |
| self.assertEqual(Oargs, [Oflag, '-O0']) |
| |
| def test_uninstall(self): |
| exename = os.path.join(self.installdir, 'usr/bin/prog') |
| testdir = os.path.join(self.common_test_dir, '8 install') |
| self.init(testdir) |
| self.assertFalse(os.path.exists(exename)) |
| self.install() |
| self.assertTrue(os.path.exists(exename)) |
| self.uninstall() |
| self.assertFalse(os.path.exists(exename)) |
| |
| def test_custom_target_exe_data_deterministic(self): |
| testdir = os.path.join(self.common_test_dir, '117 custom target capture') |
| self.init(testdir) |
| meson_exe_dat1 = glob(os.path.join(self.privatedir, 'meson_exe*.dat')) |
| self.wipe() |
| self.init(testdir) |
| meson_exe_dat2 = glob(os.path.join(self.privatedir, 'meson_exe*.dat')) |
| self.assertListEqual(meson_exe_dat1, meson_exe_dat2) |
| |
| def test_testsetups(self): |
| if not shutil.which('valgrind'): |
| raise unittest.SkipTest('Valgrind not installed.') |
| testdir = os.path.join(self.unit_test_dir, '2 testsetups') |
| self.init(testdir) |
| self.build() |
| self.run_tests() |
| with open(os.path.join(self.logdir, 'testlog.txt')) as f: |
| basic_log = f.read() |
| self.assertRaises(subprocess.CalledProcessError, |
| self._run, self.mtest_command + ['--setup=valgrind']) |
| with open(os.path.join(self.logdir, 'testlog-valgrind.txt')) as f: |
| vg_log = f.read() |
| self.assertFalse('TEST_ENV is set' in basic_log) |
| self.assertFalse('Memcheck' in basic_log) |
| self.assertTrue('TEST_ENV is set' in vg_log) |
| self.assertTrue('Memcheck' in vg_log) |
| |
| def assertFailedTestCount(self, failure_count, command): |
| try: |
| self._run(command) |
| self.assertEqual(0, failure_count, 'Expected %d tests to fail.' % failure_count) |
| except subprocess.CalledProcessError as e: |
| self.assertEqual(e.returncode, failure_count) |
| |
| def test_suite_selection(self): |
| testdir = os.path.join(self.unit_test_dir, '4 suite selection') |
| self.init(testdir) |
| self.build() |
| |
| self.assertFailedTestCount(3, self.mtest_command) |
| |
| self.assertFailedTestCount(0, self.mtest_command + ['--suite', ':success']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--suite', ':fail']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--no-suite', ':success']) |
| self.assertFailedTestCount(0, self.mtest_command + ['--no-suite', ':fail']) |
| |
| self.assertFailedTestCount(1, self.mtest_command + ['--suite', 'mainprj']) |
| self.assertFailedTestCount(0, self.mtest_command + ['--suite', 'subprjsucc']) |
| self.assertFailedTestCount(1, self.mtest_command + ['--suite', 'subprjfail']) |
| self.assertFailedTestCount(1, self.mtest_command + ['--suite', 'subprjmix']) |
| self.assertFailedTestCount(2, self.mtest_command + ['--no-suite', 'mainprj']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--no-suite', 'subprjsucc']) |
| self.assertFailedTestCount(2, self.mtest_command + ['--no-suite', 'subprjfail']) |
| self.assertFailedTestCount(2, self.mtest_command + ['--no-suite', 'subprjmix']) |
| |
| self.assertFailedTestCount(1, self.mtest_command + ['--suite', 'mainprj:fail']) |
| self.assertFailedTestCount(0, self.mtest_command + ['--suite', 'mainprj:success']) |
| self.assertFailedTestCount(2, self.mtest_command + ['--no-suite', 'mainprj:fail']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--no-suite', 'mainprj:success']) |
| |
| self.assertFailedTestCount(1, self.mtest_command + ['--suite', 'subprjfail:fail']) |
| self.assertFailedTestCount(0, self.mtest_command + ['--suite', 'subprjfail:success']) |
| self.assertFailedTestCount(2, self.mtest_command + ['--no-suite', 'subprjfail:fail']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--no-suite', 'subprjfail:success']) |
| |
| self.assertFailedTestCount(0, self.mtest_command + ['--suite', 'subprjsucc:fail']) |
| self.assertFailedTestCount(0, self.mtest_command + ['--suite', 'subprjsucc:success']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--no-suite', 'subprjsucc:fail']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--no-suite', 'subprjsucc:success']) |
| |
| self.assertFailedTestCount(1, self.mtest_command + ['--suite', 'subprjmix:fail']) |
| self.assertFailedTestCount(0, self.mtest_command + ['--suite', 'subprjmix:success']) |
| self.assertFailedTestCount(2, self.mtest_command + ['--no-suite', 'subprjmix:fail']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--no-suite', 'subprjmix:success']) |
| |
| self.assertFailedTestCount(2, self.mtest_command + ['--suite', 'subprjfail', '--suite', 'subprjmix:fail']) |
| self.assertFailedTestCount(3, self.mtest_command + ['--suite', 'subprjfail', '--suite', 'subprjmix', '--suite', 'mainprj']) |
| self.assertFailedTestCount(2, self.mtest_command + ['--suite', 'subprjfail', '--suite', 'subprjmix', '--suite', 'mainprj', '--no-suite', 'subprjmix:fail']) |
| self.assertFailedTestCount(1, self.mtest_command + ['--suite', 'subprjfail', '--suite', 'subprjmix', '--suite', 'mainprj', '--no-suite', 'subprjmix:fail', 'mainprj-failing_test']) |
| |
| self.assertFailedTestCount(1, self.mtest_command + ['--no-suite', 'subprjfail:fail', '--no-suite', 'subprjmix:fail']) |
| |
| def _test_stds_impl(self, testdir, compiler, p): |
| lang_std = p + '_std' |
| # Check that all the listed -std=xxx options for this compiler work |
| # just fine when used |
| for v in compiler.get_options()[lang_std].choices: |
| std_opt = '{}={}'.format(lang_std, v) |
| self.init(testdir, ['-D' + std_opt]) |
| cmd = self.get_compdb()[0]['command'] |
| if v != 'none': |
| cmd_std = "'-std={}'".format(v) |
| self.assertIn(cmd_std, cmd) |
| try: |
| self.build() |
| except: |
| print('{} was {!r}'.format(lang_std, v)) |
| 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' |
| env_flags = p.upper() + 'FLAGS' |
| os.environ[env_flags] = cmd_std |
| self.init(testdir) |
| cmd = self.get_compdb()[0]['command'] |
| qcmd_std = "'{}'".format(cmd_std) |
| self.assertIn(qcmd_std, cmd) |
| with self.assertRaises(subprocess.CalledProcessError, |
| msg='{} should have failed'.format(qcmd_std)): |
| 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 = Environment(testdir, self.builddir, self.meson_command, |
| get_fake_options(self.prefix), []) |
| cc = env.detect_c_compiler(False) |
| self._test_stds_impl(testdir, cc, 'c') |
| |
| 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 = Environment(testdir, self.builddir, self.meson_command, |
| get_fake_options(self.prefix), []) |
| cpp = env.detect_cpp_compiler(False) |
| self._test_stds_impl(testdir, cpp, 'cpp') |
| |
| def test_build_by_default(self): |
| testdir = os.path.join(self.common_test_dir, '137 build by default') |
| self.init(testdir) |
| self.build() |
| genfile = os.path.join(self.builddir, 'generated.dat') |
| exe = os.path.join(self.builddir, 'fooprog') |
| self.assertTrue(os.path.exists(genfile)) |
| self.assertFalse(os.path.exists(exe)) |
| self._run(self.ninja_command + ['fooprog']) |
| self.assertTrue(os.path.exists(exe)) |
| |
| def test_libdir_must_be_inside_prefix(self): |
| testdir = os.path.join(self.common_test_dir, '1 trivial') |
| # libdir being inside prefix is ok |
| args = ['--prefix', '/opt', '--libdir', '/opt/lib32'] |
| self.init(testdir, args) |
| self.wipe() |
| # libdir not being inside prefix is not ok |
| args = ['--prefix', '/usr', '--libdir', '/opt/lib32'] |
| self.assertRaises(subprocess.CalledProcessError, self.init, testdir, args) |
| self.wipe() |
| # libdir must be inside prefix even when set via mesonconf |
| self.init(testdir) |
| self.assertRaises(subprocess.CalledProcessError, self.setconf, '-Dlibdir=/opt') |
| |
| 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, '66 install subdir') |
| self.init(testdir) |
| self.install() |
| |
| f = os.path.join(self.installdir, 'usr', 'share', 'sub1') |
| 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_internal_include_order(self): |
| testdir = os.path.join(self.common_test_dir, '138 include order') |
| self.init(testdir) |
| for cmd in self.get_compdb(): |
| if cmd['file'].endswith('/main.c'): |
| cmd = cmd['command'] |
| break |
| else: |
| raise Exception('Could not find main.c command') |
| incs = [a for a in shlex.split(cmd) if a.startswith("-I")] |
| self.assertEqual(len(incs), 8) |
| # target private dir |
| self.assertEqual(incs[0], "-Isub4/someexe@exe") |
| # target build subdir |
| self.assertEqual(incs[1], "-Isub4") |
| # target source subdir |
| msg = "{!r} does not end with '/sub4'".format(incs[2]) |
| self.assertTrue(incs[2].endswith("/sub4"), msg) |
| # include paths added via per-target c_args: ['-I'...] |
| msg = "{!r} does not end with '/sub3'".format(incs[3]) |
| self.assertTrue(incs[3].endswith("/sub3"), msg) |
| # target include_directories: build dir |
| self.assertEqual(incs[4], "-Isub2") |
| # target include_directories: source dir |
| msg = "{!r} does not end with '/sub2'".format(incs[5]) |
| self.assertTrue(incs[5].endswith("/sub2"), msg) |
| # target internal dependency include_directories: build dir |
| self.assertEqual(incs[6], "-Isub1") |
| # target internal dependency include_directories: source dir |
| msg = "{!r} does not end with '/sub1'".format(incs[7]) |
| self.assertTrue(incs[7].endswith("/sub1"), msg) |
| |
| |
| class RewriterTests(unittest.TestCase): |
| |
| def setUp(self): |
| super().setUp() |
| src_root = os.path.dirname(__file__) |
| self.testroot = tempfile.mkdtemp() |
| self.rewrite_command = [sys.executable, os.path.join(src_root, 'mesonrewriter.py')] |
| self.tmpdir = tempfile.mkdtemp() |
| self.workdir = os.path.join(self.tmpdir, 'foo') |
| self.test_dir = os.path.join(src_root, 'test cases/rewrite') |
| |
| def tearDown(self): |
| shutil.rmtree(self.tmpdir) |
| |
| def read_contents(self, fname): |
| with open(os.path.join(self.workdir, fname)) as f: |
| return f.read() |
| |
| def check_effectively_same(self, mainfile, truth): |
| mf = self.read_contents(mainfile) |
| t = self.read_contents(truth) |
| # Rewriting is not guaranteed to do a perfect job of |
| # maintaining whitespace. |
| self.assertEqual(mf.replace(' ', ''), t.replace(' ', '')) |
| |
| def prime(self, dirname): |
| shutil.copytree(os.path.join(self.test_dir, dirname), self.workdir) |
| |
| def test_basic(self): |
| self.prime('1 basic') |
| subprocess.check_output(self.rewrite_command + ['remove', |
| '--target=trivialprog', |
| '--filename=notthere.c', |
| '--sourcedir', self.workdir]) |
| self.check_effectively_same('meson.build', 'removed.txt') |
| subprocess.check_output(self.rewrite_command + ['add', |
| '--target=trivialprog', |
| '--filename=notthere.c', |
| '--sourcedir', self.workdir]) |
| self.check_effectively_same('meson.build', 'added.txt') |
| subprocess.check_output(self.rewrite_command + ['remove', |
| '--target=trivialprog', |
| '--filename=notthere.c', |
| '--sourcedir', self.workdir]) |
| self.check_effectively_same('meson.build', 'removed.txt') |
| |
| def test_subdir(self): |
| self.prime('2 subdirs') |
| top = self.read_contents('meson.build') |
| s2 = self.read_contents('sub2/meson.build') |
| subprocess.check_output(self.rewrite_command + ['remove', |
| '--target=something', |
| '--filename=second.c', |
| '--sourcedir', self.workdir]) |
| self.check_effectively_same('sub1/meson.build', 'sub1/after.txt') |
| self.assertEqual(top, self.read_contents('meson.build')) |
| self.assertEqual(s2, self.read_contents('sub2/meson.build')) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
