test/lit.cfg - platform/external/libcxxabi - Git at Google

 # -*- Python -*- vim: set syntax=python tabstop=4 expandtab cc=80:

 # Configuration file for the 'lit' test runner.

 import errno
 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 LibcxxabiTestFormat(lit.formats.FileBasedTest):
     """
     Custom test format handler for use with the test format use by libc++abi.
     """

     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.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)

         # If this is a compile (failure) test, build it and check for failure.
         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++abi'

 # 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__)

 # 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++)')

 libcxxabi_src_root = lit_config.params.get('libcxxabi_src_root', None)
 if libcxxabi_src_root is None:
     libcxxabi_src_root = getattr(config, 'libcxxabi_src_root', None)
     if libcxxabi_src_root is None:
         libcxxabi_src_root = os.path.dirname(config.test_source_root)

 libcxxabi_obj_root = lit_config.params.get('libcxxabi_obj_root', None)
 if libcxxabi_obj_root is None:
     libcxxabi_obj_root = getattr(config, 'libcxxabi_obj_root', None)
     if libcxxabi_obj_root is None:
         libcxxabi_obj_root = libcxxabi_src_root

 libcxx_includes = lit_config.params.get('libcxx_includes', None)
 if libcxx_includes is None:
     libcxx_includes = getattr(config, 'libcxx_includes', None)
     if libcxx_includes is None:
         lit_config.fatal("libcxx_includes must be defined")

 enable_shared = lit_config.params.get('enable_shared', None)
 if enable_shared is None:
     enable_shared = getattr(config, 'enable_shared', None)
     if enable_shared is None:
         lit_config.fatal("enable_shared must be defined")

 llvm_unwinder = getattr(config, 'llvm_unwinder', None)
 if llvm_unwinder is None:
     lit_config.fatal("llvm_unwinder must be defined")

 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:
         if enable_shared:
             link_flags += ['-lc++abi']
         if sys.platform == 'darwin':
             link_flags += ['-lSystem']
         elif sys.platform == 'linux2':
             if not llvm_unwinder:
                 link_flags += ['-lgcc_eh']
             link_flags += ['-lc', '-lm', '-lpthread']
             if llvm_unwinder:
                 link_flags += ['-lunwind', '-ldl']
             else:
                 link_flags += ['-lgcc_s']
         else:
             lit_config.fatal("unrecognized system")

         lit_config.note("inferred link_flags as: %r" % (link_flags,))
 if link_flags_str is not None:
     link_flags += shlex.split(link_flags_str)

 # Configure extra compiler flags.
 include_paths = ['-I' + libcxxabi_src_root + '/include',
                  '-I' + libcxx_includes]
 library_paths = ['-L' + libcxxabi_obj_root + '/lib']
 compile_flags = ['-std=c++11']

 # Configure extra linker parameters.
 exec_env = {}
 if sys.platform == 'darwin':
     exec_env['DYLD_LIBRARY_PATH'] = os.path.join(libcxxabi_obj_root, 'lib')
 elif sys.platform == 'linux2':
     link_flags += ['-Wl,-R', libcxxabi_obj_root + '/lib']
 else:
     lit_config.fatal("unrecognized system")

 config.test_format = LibcxxabiTestFormat(
     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,))
	# -- Python -- vim: set syntax=python tabstop=4 expandtab cc=80:

	# Configuration file for the 'lit' test runner.

	import errno
	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 LibcxxabiTestFormat(lit.formats.FileBasedTest):
	"""
	Custom test format handler for use with the test format use by libc++abi.
	"""

	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.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)

	# If this is a compile (failure) test, build it and check for failure.
	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++abi'

	# 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__)

	# 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++)')

	libcxxabi_src_root = lit_config.params.get('libcxxabi_src_root', None)
	if libcxxabi_src_root is None:
	libcxxabi_src_root = getattr(config, 'libcxxabi_src_root', None)
	if libcxxabi_src_root is None:
	libcxxabi_src_root = os.path.dirname(config.test_source_root)

	libcxxabi_obj_root = lit_config.params.get('libcxxabi_obj_root', None)
	if libcxxabi_obj_root is None:
	libcxxabi_obj_root = getattr(config, 'libcxxabi_obj_root', None)
	if libcxxabi_obj_root is None:
	libcxxabi_obj_root = libcxxabi_src_root

	libcxx_includes = lit_config.params.get('libcxx_includes', None)
	if libcxx_includes is None:
	libcxx_includes = getattr(config, 'libcxx_includes', None)
	if libcxx_includes is None:
	lit_config.fatal("libcxx_includes must be defined")

	enable_shared = lit_config.params.get('enable_shared', None)
	if enable_shared is None:
	enable_shared = getattr(config, 'enable_shared', None)
	if enable_shared is None:
	lit_config.fatal("enable_shared must be defined")

	llvm_unwinder = getattr(config, 'llvm_unwinder', None)
	if llvm_unwinder is None:
	lit_config.fatal("llvm_unwinder must be defined")

	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:
	if enable_shared:
	link_flags += ['-lc++abi']
	if sys.platform == 'darwin':
	link_flags += ['-lSystem']
	elif sys.platform == 'linux2':
	if not llvm_unwinder:
	link_flags += ['-lgcc_eh']
	link_flags += ['-lc', '-lm', '-lpthread']
	if llvm_unwinder:
	link_flags += ['-lunwind', '-ldl']
	else:
	link_flags += ['-lgcc_s']
	else:
	lit_config.fatal("unrecognized system")

	lit_config.note("inferred link_flags as: %r" % (link_flags,))
	if link_flags_str is not None:
	link_flags += shlex.split(link_flags_str)

	# Configure extra compiler flags.
	include_paths = ['-I' + libcxxabi_src_root + '/include',
	'-I' + libcxx_includes]
	library_paths = ['-L' + libcxxabi_obj_root + '/lib']
	compile_flags = ['-std=c++11']

	# Configure extra linker parameters.
	exec_env = {}
	if sys.platform == 'darwin':
	exec_env['DYLD_LIBRARY_PATH'] = os.path.join(libcxxabi_obj_root, 'lib')
	elif sys.platform == 'linux2':
	link_flags += ['-Wl,-R', libcxxabi_obj_root + '/lib']
	else:
	lit_config.fatal("unrecognized system")

	config.test_format = LibcxxabiTestFormat(
	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,))