generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
529d303340
cxx/test/lit.cfg
Dan Albert b4ed5ca01e Add locales to available_features for tests. 
Linux has a lot of failures caused by not having support for certain
locales. Since these come out as a lot of noise in the test results,
have lit.cfg detect the presence of the various locales used in the
tests and add them to config.available_features as locale.LOCALE_NAME.

This patch also adds REQUIRES: locale.REQUIRED_LOCALE to every test that
I saw failing in this manner. We probably need to add more for all the
tests requiring en_US.UTF-8, but we can do that on an as-needed basis.

One thing that concerns me is how many tests get skipped because of
missing locales (especially in regex/). We should make a point of
splitting up any tests that test default behavior _and_ behavior under a
given locale so that we aren't losing coverage for default behavior.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@214753 91177308-0d34-0410-b5e6-96231b3b80d8
2014-08-04 18:44:48 +00:00

344 lines
13 KiB
Python
Raw Blame History

# -*- Python -*- vim: set syntax=python tabstop=4 expandtab cc=80:
# Configuration file for the 'lit' test runner.
import errno
import locale
import os
import platform
import re
import shlex
import signal
import subprocess
import sys
import tempfile
import time
import lit.Test
import lit.formats
import lit.util
class LibcxxTestFormat(lit.formats.FileBasedTest):
"""
Custom test format handler for use with the test format use by libc++.
Tests fall into two categories:
FOO.pass.cpp - Executable test which should compile, run, and exit with
code 0.
FOO.fail.cpp - Negative test case which is expected to fail compilation.
"""
def __init__(self, cxx_under_test, cpp_flags, ld_flags, exec_env):
self.cxx_under_test = cxx_under_test
self.cpp_flags = list(cpp_flags)
self.ld_flags = list(ld_flags)
self.exec_env = dict(exec_env)
def execute_command(self, command, in_dir=None):
kwargs = {
'stdin' :subprocess.PIPE,
'stdout':subprocess.PIPE,
'stderr':subprocess.PIPE,
}
if in_dir:
kwargs['cwd'] = in_dir
p = subprocess.Popen(command, **kwargs)
out,err = p.communicate()
exitCode = p.wait()
# Detect Ctrl-C in subprocess.
if exitCode == -signal.SIGINT:
raise KeyboardInterrupt
return out, err, exitCode
def execute(self, test, lit_config):
while True:
try:
return self._execute(test, lit_config)
except OSError, oe:
if oe.errno != errno.ETXTBSY:
raise
time.sleep(0.1)
def _execute(self, test, lit_config):
# Extract test metadata from the test file.
requires = []
with open(test.getSourcePath()) as f:
for ln in f:
if 'XFAIL:' in ln:
items = ln[ln.index('XFAIL:') + 6:].split(',')
test.xfails.extend([s.strip() for s in items])
elif 'REQUIRES:' in ln:
items = ln[ln.index('REQUIRES:') + 9:].split(',')
requires.extend([s.strip() for s in items])
elif not ln.strip().startswith("//") and ln.strip():
# Stop at the first non-empty line that is not a C++
# comment.
break
# Check that we have the required features.
#
# FIXME: For now, this is cribbed from lit.TestRunner, to avoid
# introducing a dependency there. What we more ideally would like to do
# is lift the "requires" handling to be a core lit framework feature.
missing_required_features = [f for f in requires
if f not in test.config.available_features]
if missing_required_features:
return (lit.Test.UNSUPPORTED,
"Test requires the following features: %s" % (
', '.join(missing_required_features),))
# Evaluate the test.
return self._evaluate_test(test, lit_config)
def _evaluate_test(self, test, lit_config):
name = test.path_in_suite[-1]
source_path = test.getSourcePath()
source_dir = os.path.dirname(source_path)
# Check what kind of test this is.
assert name.endswith('.pass.cpp') or name.endswith('.fail.cpp')
expected_compile_fail = name.endswith('.fail.cpp')
# If this is a compile (failure) test, build it and check for failure.
if expected_compile_fail:
cmd = [self.cxx_under_test, '-c',
'-o', '/dev/null', source_path] + self.cpp_flags
out, err, exitCode = self.execute_command(cmd)
if exitCode == 1:
return lit.Test.PASS, ""
else:
report = """Command: %s\n""" % ' '.join(["'%s'" % a
for a in cmd])
report += """Exit Code: %d\n""" % exitCode
if out:
report += """Standard Output:\n--\n%s--""" % out
if err:
report += """Standard Error:\n--\n%s--""" % err
report += "\n\nExpected compilation to fail!"
return lit.Test.FAIL, report
else:
exec_file = tempfile.NamedTemporaryFile(suffix="exe", delete=False)
exec_path = exec_file.name
exec_file.close()
try:
compile_cmd = [self.cxx_under_test, '-o', exec_path,
source_path] + self.cpp_flags + self.ld_flags
cmd = compile_cmd
out, err, exitCode = self.execute_command(cmd)
if exitCode != 0:
report = """Command: %s\n""" % ' '.join(["'%s'" % a
for a in cmd])
report += """Exit Code: %d\n""" % exitCode
if out:
report += """Standard Output:\n--\n%s--""" % out
if err:
report += """Standard Error:\n--\n%s--""" % err
report += "\n\nCompilation failed unexpectedly!"
return lit.Test.FAIL, report
cmd = []
if self.exec_env:
cmd.append('env')
cmd.extend('%s=%s' % (name, value)
for name,value in self.exec_env.items())
cmd.append(exec_path)
if lit_config.useValgrind:
cmd = lit_config.valgrindArgs + cmd
out, err, exitCode = self.execute_command(cmd, source_dir)
if exitCode != 0:
report = """Compiled With: %s\n""" % \
' '.join(["'%s'" % a for a in compile_cmd])
report += """Command: %s\n""" % \
' '.join(["'%s'" % a for a in cmd])
report += """Exit Code: %d\n""" % exitCode
if out:
report += """Standard Output:\n--\n%s--""" % out
if err:
report += """Standard Error:\n--\n%s--""" % err
report += "\n\nCompiled test failed unexpectedly!"
return lit.Test.FAIL, report
finally:
try:
os.remove(exec_path)
except:
pass
return lit.Test.PASS, ""
# name: The name of this test suite.
config.name = 'libc++'
# suffixes: A list of file extensions to treat as test files.
config.suffixes = ['.cpp']
# test_source_root: The root path where tests are located.
config.test_source_root = os.path.dirname(__file__)
# Figure out which of the required locales we support
locales = {
'Darwin': {
'en_US.UTF-8': 'en_US.UTF-8',
'cs_CZ.ISO8859-2': 'cs_CZ.ISO8859-2',
'fr_FR.UTF-8': 'fr_FR.UTF-8',
'fr_CA.ISO8859-1': 'cs_CZ.ISO8859-1',
'ru_RU.UTF-8': 'ru_RU.UTF-8',
'zh_CN.UTF-8': 'zh_CN.UTF-8',
},
'Linux': {
'en_US.UTF-8': 'en_US.UTF-8',
'cs_CZ.ISO8859-2': 'cs_CZ.ISO-8859-2',
'fr_FR.UTF-8': 'fr_FR.UTF-8',
'fr_CA.ISO8859-1': 'fr_CA.ISO-8859-1',
'ru_RU.UTF-8': 'ru_RU.UTF-8',
'zh_CN.UTF-8': 'zh_CN.UTF-8',
},
'Windows': {
'en_US.UTF-8': 'English_United States.1252',
'cs_CZ.ISO8859-2': 'Czech_Czech Republic.1250',
'fr_FR.UTF-8': 'French_France.1252',
'fr_CA.ISO8859-1': 'French_Canada.1252',
'ru_RU.UTF-8': 'Russian_Russia.1251',
'zh_CN.UTF-8': 'Chinese_China.936',
},
}
for feature, loc in locales[platform.system()].items():
try:
locale.setlocale(locale.LC_ALL, loc)
config.available_features.add('locale.{}'.format(feature))
except:
lit_config.warning('The locale {} is not supported by your platoform. '
'Some tests will be unsupported.'.format(loc))
# Gather various compiler parameters.
cxx_under_test = lit_config.params.get('cxx_under_test', None)
if cxx_under_test is None:
cxx_under_test = getattr(config, 'cxx_under_test', None)
# If no specific cxx_under_test was given, attempt to infer it as clang++.
if cxx_under_test is None:
clangxx = lit.util.which('clang++', config.environment['PATH'])
if clangxx is not None:
cxx_under_test = clangxx
lit_config.note("inferred cxx_under_test as: %r" % (cxx_under_test,))
if cxx_under_test is None:
lit_config.fatal('must specify user parameter cxx_under_test '
'(e.g., --param=cxx_under_test=clang++)')
libcxx_src_root = lit_config.params.get('libcxx_src_root', None)
if libcxx_src_root is None:
libcxx_src_root = getattr(config, 'libcxx_src_root', None)
if libcxx_src_root is None:
libcxx_src_root = os.path.dirname(config.test_source_root)
libcxx_obj_root = lit_config.params.get('libcxx_obj_root', None)
if libcxx_obj_root is None:
libcxx_obj_root = getattr(config, 'libcxx_obj_root', None)
if libcxx_obj_root is None:
libcxx_obj_root = libcxx_src_root
cxx_has_stdcxx0x_flag_str = lit_config.params.get('cxx_has_stdcxx0x_flag', None)
if cxx_has_stdcxx0x_flag_str is not None:
if cxx_has_stdcxx0x_flag_str.lower() in ('1', 'true'):
cxx_has_stdcxx0x_flag = True
elif cxx_has_stdcxx0x_flag_str.lower() in ('', '0', 'false'):
cxx_has_stdcxx0x_flag = False
else:
lit_config.fatal(
'user parameter cxx_has_stdcxx0x_flag_str should be 0 or 1')
else:
cxx_has_stdcxx0x_flag = getattr(config, 'cxx_has_stdcxx0x_flag', True)
# This test suite supports testing against either the system library or the
# locally built one; the former mode is useful for testing ABI compatibility
# between the current headers and a shipping dynamic library.
use_system_lib_str = lit_config.params.get('use_system_lib', None)
if use_system_lib_str is not None:
if use_system_lib_str.lower() in ('1', 'true'):
use_system_lib = True
elif use_system_lib_str.lower() in ('', '0', 'false'):
use_system_lib = False
else:
lit_config.fatal('user parameter use_system_lib should be 0 or 1')
else:
# Default to testing against the locally built libc++ library.
use_system_lib = False
lit_config.note("inferred use_system_lib as: %r" % (use_system_lib,))
link_flags = []
link_flags_str = lit_config.params.get('link_flags', None)
if link_flags_str is None:
link_flags_str = getattr(config, 'link_flags', None)
if link_flags_str is None:
cxx_abi = getattr(config, 'cxx_abi', 'libcxxabi')
if cxx_abi == 'libstdc++':
link_flags += ['-lstdc++']
elif cxx_abi == 'libsupc++':
link_flags += ['-lsupc++']
elif cxx_abi == 'libcxxabi':
link_flags += ['-lc++abi']
elif cxx_abi == 'none':
pass
else:
lit_config.fatal('C++ ABI setting %s unsupported for tests' % cxx_abi)
if sys.platform == 'darwin':
link_flags += ['-lSystem']
elif sys.platform == 'linux2':
link_flags += [ '-lgcc_eh', '-lc', '-lm', '-lpthread',
'-lrt', '-lgcc_s']
else:
lit_config.fatal("unrecognized system")
lit_config.note("inferred link_flags as: %r" % (link_flags,))
if not link_flags_str is None:
link_flags += shlex.split(link_flags_str)
# Configure extra compiler flags.
include_paths = ['-I' + libcxx_src_root + '/include',
'-I' + libcxx_src_root + '/test/support']
library_paths = ['-L' + libcxx_obj_root + '/lib']
compile_flags = []
if cxx_has_stdcxx0x_flag:
compile_flags += ['-std=c++0x']
# Configure extra linker parameters.
exec_env = {}
if sys.platform == 'darwin':
if not use_system_lib:
exec_env['DYLD_LIBRARY_PATH'] = os.path.join(libcxx_obj_root, 'lib')
elif sys.platform == 'linux2':
if not use_system_lib:
link_flags += ['-Wl,-R', libcxx_obj_root + '/lib']
compile_flags += ['-D__STDC_FORMAT_MACROS', '-D__STDC_LIMIT_MACROS',
'-D__STDC_CONSTANT_MACROS']
else:
lit_config.fatal("unrecognized system")
config.test_format = LibcxxTestFormat(
cxx_under_test,
cpp_flags = ['-nostdinc++'] + compile_flags + include_paths,
ld_flags = ['-nodefaultlibs'] + library_paths + ['-lc++'] + link_flags,
exec_env = exec_env)
# Get or infer the target triple.
config.target_triple = lit_config.params.get('target_triple', None)
# If no target triple was given, try to infer it from the compiler under test.
if config.target_triple is None:
config.target_triple = lit.util.capture(
[cxx_under_test, '-dumpmachine']).strip()
lit_config.note("inferred target_triple as: %r" % (config.target_triple,))
# Write an "available feature" that combines the triple when use_system_lib is
# enabled. This is so that we can easily write XFAIL markers for tests that are
# known to fail with versions of libc++ as were shipped with a particular
# triple.
if use_system_lib:
# Drop sub-major version components from the triple, because the current
# XFAIL handling expects exact matches for feature checks.
sanitized_triple = re.sub(r"([^-]+)-([^-]+)-([^-.]+).*", r"\1-\2-\3",
config.target_triple)
config.available_features.add('with_system_lib=%s' % (sanitized_triple,))
Reference in New Issue View Git Blame Copy Permalink