mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-15 01:21:06 +00:00
95edd05c75
In <https://sourceware.org/ml/libc-alpha/2018-11/msg00225.html>, Florian reported that the change from conformtest.pl to conformtest.py had increased conform/ test time, possibly because of increased startup overhead for Python scripts. This patch improves conformtest.py performance by arranging for as many tests of a (header, standard) pair as possible to use a single execution of the compiler, so it does not need to initialize and parse the whole header under test separately for every test assertion. Specifically, compilation tests that are not marked as "optional" or "xfail" are combined into a single source file, and are only then run separately if compilation of that combined file fails. For me, this reduces the wall clock time for the conformtest.py tests (not the whole of the conform/ directory) from two minutes to 15 seconds. Tested for x86_64, and with build-many-glibcs.py. * conform/conformtest.py (CompileSubTest.__init__): Set self.run_early to False. (ExecuteSubTest.__init__): Likewise. (HeaderTests.run): Try running all non-optional, non-XFAILed compilation tests in a single execution of the compiler.
735 lines
28 KiB
Python
735 lines
28 KiB
Python
#!/usr/bin/python3
|
|
# Check header contents against the given standard.
|
|
# Copyright (C) 2018 Free Software Foundation, Inc.
|
|
# This file is part of the GNU C Library.
|
|
#
|
|
# The GNU C Library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2.1 of the License, or (at your option) any later version.
|
|
#
|
|
# The GNU C Library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with the GNU C Library; if not, see
|
|
# <http://www.gnu.org/licenses/>.
|
|
|
|
import argparse
|
|
import fnmatch
|
|
import os.path
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
|
|
import glibcconform
|
|
|
|
|
|
class CompileSubTest(object):
|
|
"""A compilation subtest."""
|
|
|
|
def __init__(self, name, text):
|
|
"""Initialize a CompileSubTest object."""
|
|
self.run_early = False
|
|
self.name = name
|
|
self.text = text
|
|
|
|
def run(self, header_tests):
|
|
"""Run a compilation subtest."""
|
|
header_tests.compile_test(self.name, self.text)
|
|
|
|
|
|
class ExecuteSubTest(object):
|
|
"""An execution subtest."""
|
|
|
|
def __init__(self, name, text):
|
|
"""Initialize an ExecuteSubTest object."""
|
|
self.run_early = False
|
|
self.name = name
|
|
self.text = text
|
|
|
|
def run(self, header_tests):
|
|
"""Run an execution subtest."""
|
|
header_tests.execute_test(self.name, self.text)
|
|
|
|
|
|
class ElementTest(object):
|
|
"""Test for an element of a structure or union type."""
|
|
|
|
def __init__(self, dummy, type_name, member_type, member_name, *rest):
|
|
"""Initialize an ElementTest object."""
|
|
self.type_name = type_name
|
|
self.member_type = member_type
|
|
self.member_name = member_name
|
|
self.rest = ' '.join(rest)
|
|
self.allow_name = self.member_name
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for an ElementTest."""
|
|
text = ('%(type_name)s a_%(num)d;\n'
|
|
'%(type_name)s b_%(num)d;\n'
|
|
'extern void xyzzy_%(num)d '
|
|
'(__typeof__ (&b_%(num)d.%(member_name)s), '
|
|
'__typeof__ (&a_%(num)d.%(member_name)s), unsigned);\n'
|
|
'void foobarbaz_%(num)d (void) {\n'
|
|
'xyzzy_%(num)d (&a_%(num)d.%(member_name)s, '
|
|
'&b_%(num)d.%(member_name)s, '
|
|
'sizeof (a_%(num)d.%(member_name)s));\n'
|
|
'}\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of member %s' % self.member_name,
|
|
text))
|
|
text = ('%(type_name)s a2_%(num)d;\n'
|
|
'extern %(member_type)s b2_%(num)d%(rest)s;\n'
|
|
'extern __typeof__ (a2_%(num)d.%(member_name)s) b2_%(num)d;\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Type of member %s' % self.member_name,
|
|
text))
|
|
|
|
|
|
class ConstantTest(object):
|
|
"""Test for a macro or constant."""
|
|
|
|
def __init__(self, symbol_type, symbol, extra1=None, extra2=None,
|
|
extra3=None):
|
|
"""Initialize a ConstantTest object."""
|
|
self.symbol_type = symbol_type
|
|
self.symbol = symbol
|
|
# A comparison operation may be specified without a type.
|
|
if extra2 is not None and extra3 is None:
|
|
self.c_type = None
|
|
self.op = extra1
|
|
self.value = extra2
|
|
else:
|
|
self.c_type = extra1
|
|
self.op = extra2
|
|
self.value = extra3
|
|
self.allow_name = self.symbol
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a ConstantTest."""
|
|
if 'macro' in self.symbol_type:
|
|
text = ('#ifndef %(symbol)s\n'
|
|
'# error "Macro %(symbol)s not defined"\n'
|
|
'#endif\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of macro %s' % self.symbol,
|
|
text))
|
|
if 'constant' in self.symbol_type:
|
|
text = ('__typeof__ (%(symbol)s) a_%(num)d = %(symbol)s;\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of constant %s' % self.symbol,
|
|
text))
|
|
if self.symbol_type == 'macro-int-constant':
|
|
sym_bits_def_neg = ''.join(
|
|
'# if %s & (1LL << %d)\n'
|
|
'# define conformtest_%d_bit_%d 0LL\n'
|
|
'# else\n'
|
|
'# define conformtest_%d_bit_%d (1LL << %d)\n'
|
|
'# endif\n'
|
|
% (self.symbol, i, self.num, i, self.num, i, i)
|
|
for i in range(63))
|
|
sym_bits_or_neg = '|'.join('conformtest_%d_bit_%d' % (self.num, i)
|
|
for i in range(63))
|
|
sym_bits_def_pos = ''.join(
|
|
'# if %s & (1ULL << %d)\n'
|
|
'# define conformtest_%d_bit_%d (1ULL << %d)\n'
|
|
'# else\n'
|
|
'# define conformtest_%d_bit_%d 0ULL\n'
|
|
'# endif\n'
|
|
% (self.symbol, i, self.num, i, i, self.num, i)
|
|
for i in range(64))
|
|
sym_bits_or_pos = '|'.join('conformtest_%d_bit_%d' % (self.num, i)
|
|
for i in range(64))
|
|
text = ('#if %s < 0\n'
|
|
'# define conformtest_%d_negative 1\n'
|
|
'%s'
|
|
'# define conformtest_%d_value ~(%s)\n'
|
|
'#else\n'
|
|
'# define conformtest_%d_negative 0\n'
|
|
'%s'
|
|
'# define conformtest_%d_value (%s)\n'
|
|
'#endif\n'
|
|
'_Static_assert (((%s < 0) == conformtest_%d_negative) '
|
|
'&& (%s == conformtest_%d_value), '
|
|
'"value match inside and outside #if");\n'
|
|
% (self.symbol, self.num, sym_bits_def_neg, self.num,
|
|
sym_bits_or_neg, self.num, sym_bits_def_pos, self.num,
|
|
sym_bits_or_pos, self.symbol, self.num, self.symbol,
|
|
self.num))
|
|
self.subtests.append(CompileSubTest(
|
|
'#if usability of symbol %s'% self.symbol,
|
|
text))
|
|
if self.c_type is not None:
|
|
if self.c_type.startswith('promoted:'):
|
|
c_type = self.c_type[len('promoted:'):]
|
|
text = ('__typeof__ ((%s) 0 + (%s) 0) a2_%d;\n'
|
|
% (c_type, c_type, self.num))
|
|
else:
|
|
text = '__typeof__ ((%s) 0) a2_%d;\n' % (self.c_type, self.num)
|
|
text += 'extern __typeof__ (%s) a2_%d;\n' % (self.symbol, self.num)
|
|
self.subtests.append(CompileSubTest(
|
|
'Type of symbol %s' % self.symbol,
|
|
text))
|
|
if self.op is not None:
|
|
text = ('_Static_assert (%(symbol)s %(op)s %(value)s, '
|
|
'"value constraint");\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Value of symbol %s' % self.symbol,
|
|
text))
|
|
|
|
|
|
class SymbolTest(object):
|
|
"""Test for a symbol (not a compile-time constant)."""
|
|
|
|
def __init__(self, dummy, symbol, value=None):
|
|
"""Initialize a SymbolTest object."""
|
|
self.symbol = symbol
|
|
self.value = value
|
|
self.allow_name = self.symbol
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a SymbolTest."""
|
|
text = ('void foobarbaz_%(num)d (void) {\n'
|
|
'__typeof__ (%(symbol)s) a_%(num)d = %(symbol)s;\n'
|
|
'}\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of symbol %s' % self.symbol,
|
|
text))
|
|
if self.value is not None:
|
|
text = ('int main (void) { return %(symbol)s != %(symbol)s; }\n'
|
|
% vars(self))
|
|
self.subtests.append(ExecuteSubTest(
|
|
'Value of symbol %s' % self.symbol,
|
|
text))
|
|
|
|
|
|
class TypeTest(object):
|
|
"""Test for a type name."""
|
|
|
|
def __init__(self, dummy, type_name):
|
|
"""Initialize a TypeTest object."""
|
|
self.type_name = type_name
|
|
if type_name.startswith('struct '):
|
|
self.allow_name = type_name[len('struct '):]
|
|
self.maybe_opaque = False
|
|
elif type_name.startswith('union '):
|
|
self.allow_name = type_name[len('union '):]
|
|
self.maybe_opaque = False
|
|
else:
|
|
self.allow_name = type_name
|
|
self.maybe_opaque = True
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a TypeTest."""
|
|
text = ('%s %sa_%d;\n'
|
|
% (self.type_name, '*' if self.maybe_opaque else '', self.num))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of type %s' % self.type_name,
|
|
text))
|
|
|
|
|
|
class TagTest(object):
|
|
"""Test for a tag name."""
|
|
|
|
def __init__(self, dummy, type_name):
|
|
"""Initialize a TagTest object."""
|
|
self.type_name = type_name
|
|
if type_name.startswith('struct '):
|
|
self.allow_name = type_name[len('struct '):]
|
|
elif type_name.startswith('union '):
|
|
self.allow_name = type_name[len('union '):]
|
|
else:
|
|
raise ValueError('unexpected kind of tag: %s' % type_name)
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a TagTest."""
|
|
# If the tag is not declared, these function prototypes have
|
|
# incompatible types.
|
|
text = ('void foo_%(num)d (%(type_name)s *);\n'
|
|
'void foo_%(num)d (%(type_name)s *);\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of tag %s' % self.type_name,
|
|
text))
|
|
|
|
|
|
class FunctionTest(object):
|
|
"""Test for a function."""
|
|
|
|
def __init__(self, dummy, return_type, function_name, *args):
|
|
"""Initialize a FunctionTest object."""
|
|
self.function_name_full = function_name
|
|
self.args = ' '.join(args)
|
|
if function_name.startswith('(*'):
|
|
# Function returning a pointer to function.
|
|
self.return_type = '%s (*' % return_type
|
|
self.function_name = function_name[len('(*'):]
|
|
else:
|
|
self.return_type = return_type
|
|
self.function_name = function_name
|
|
self.allow_name = self.function_name
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a FunctionTest."""
|
|
text = ('%(return_type)s (*foobarbaz_%(num)d) %(args)s '
|
|
'= %(function_name)s;\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of function %s' % self.function_name,
|
|
text))
|
|
text = ('extern %(return_type)s (*foobarbaz2_%(num)d) %(args)s;\n'
|
|
'extern __typeof__ (&%(function_name)s) foobarbaz2_%(num)d;\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Type of function %s' % self.function_name,
|
|
text))
|
|
|
|
|
|
class VariableTest(object):
|
|
"""Test for a variable."""
|
|
|
|
def __init__(self, dummy, var_type, var_name, *rest):
|
|
"""Initialize a VariableTest object."""
|
|
self.var_type = var_type
|
|
self.var_name = var_name
|
|
self.rest = ' '.join(rest)
|
|
self.allow_name = var_name
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a VariableTest."""
|
|
text = ('typedef %(var_type)s xyzzy_%(num)d%(rest)s;\n'
|
|
'xyzzy_%(num)d *foobarbaz_%(num)d = &%(var_name)s;\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of variable %s' % self.var_name,
|
|
text))
|
|
text = ('extern %(var_type)s %(var_name)s%(rest)s;\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Type of variable %s' % self.var_name,
|
|
text))
|
|
|
|
|
|
class MacroFunctionTest(object):
|
|
"""Test for a possibly macro-only function."""
|
|
|
|
def __init__(self, dummy, return_type, function_name, *args):
|
|
"""Initialize a MacroFunctionTest object."""
|
|
self.return_type = return_type
|
|
self.function_name = function_name
|
|
self.args = ' '.join(args)
|
|
self.allow_name = function_name
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a MacroFunctionTest."""
|
|
text = ('#ifndef %(function_name)s\n'
|
|
'%(return_type)s (*foobarbaz_%(num)d) %(args)s '
|
|
'= %(function_name)s;\n'
|
|
'#endif\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of macro %s' % self.function_name,
|
|
text))
|
|
text = ('#ifndef %(function_name)s\n'
|
|
'extern %(return_type)s (*foobarbaz2_%(num)d) %(args)s;\n'
|
|
'extern __typeof__ (&%(function_name)s) foobarbaz2_%(num)d;\n'
|
|
'#endif\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Type of macro %s' % self.function_name,
|
|
text))
|
|
|
|
|
|
class MacroStrTest(object):
|
|
"""Test for a string-valued macro."""
|
|
|
|
def __init__(self, dummy, macro_name, value):
|
|
"""Initialize a MacroStrTest object."""
|
|
self.macro_name = macro_name
|
|
self.value = value
|
|
self.allow_name = macro_name
|
|
|
|
def gen_subtests(self):
|
|
"""Generate subtests for a MacroStrTest."""
|
|
text = ('#ifndef %(macro_name)s\n'
|
|
'# error "Macro %(macro_name)s not defined"\n'
|
|
'#endif\n'
|
|
% vars(self))
|
|
self.subtests.append(CompileSubTest(
|
|
'Availability of macro %s' % self.macro_name,
|
|
text))
|
|
# We can't include <string.h> here.
|
|
text = ('extern int (strcmp)(const char *, const char *);\n'
|
|
'int main (void) { return (strcmp) (%(macro_name)s, '
|
|
'%(value)s) != 0; }\n'
|
|
% vars(self))
|
|
self.subtests.append(ExecuteSubTest(
|
|
'Value of macro %s' % self.macro_name,
|
|
text))
|
|
|
|
|
|
class HeaderTests(object):
|
|
"""The set of tests run for a header."""
|
|
|
|
def __init__(self, header, standard, cc, flags, cross, xfail):
|
|
"""Initialize a HeaderTests object."""
|
|
self.header = header
|
|
self.standard = standard
|
|
self.cc = cc
|
|
self.flags = flags
|
|
self.cross = cross
|
|
self.xfail_str = xfail
|
|
self.cflags_namespace = ('%s -fno-builtin %s -D_ISOMAC'
|
|
% (flags, glibcconform.CFLAGS[standard]))
|
|
# When compiling the conformance test programs, use of
|
|
# __attribute__ in headers is disabled because of attributes
|
|
# that affect the types of functions as seen by typeof.
|
|
self.cflags = "%s '-D__attribute__(x)='" % self.cflags_namespace
|
|
self.tests = []
|
|
self.allow = set()
|
|
self.allow_fnmatch = set()
|
|
self.headers_handled = set()
|
|
self.num_tests = 0
|
|
self.total = 0
|
|
self.skipped = 0
|
|
self.errors = 0
|
|
self.xerrors = 0
|
|
|
|
def add_allow(self, name, pattern_ok):
|
|
"""Add an identifier as an allowed token for this header.
|
|
|
|
If pattern_ok, fnmatch patterns are OK as well as
|
|
identifiers.
|
|
|
|
"""
|
|
if re.fullmatch(r'[A-Za-z_][A-Za-z0-9_]*', name):
|
|
self.allow.add(name)
|
|
elif pattern_ok:
|
|
self.allow_fnmatch.add(name)
|
|
else:
|
|
raise ValueError('bad identifier: %s' % name)
|
|
|
|
def check_token(self, bad_tokens, token):
|
|
"""Check whether an identifier token is allowed, and record it in
|
|
bad_tokens if not.
|
|
|
|
"""
|
|
if token.startswith('_'):
|
|
return
|
|
if token in glibcconform.KEYWORDS[self.standard]:
|
|
return
|
|
if token in self.allow:
|
|
return
|
|
for pattern in self.allow_fnmatch:
|
|
if fnmatch.fnmatch(token, pattern):
|
|
return
|
|
bad_tokens.add(token)
|
|
|
|
def handle_test_line(self, line, allow):
|
|
"""Handle a single line in the test data.
|
|
|
|
If allow is true, the header is one specified in allow-header
|
|
and so tests are marked as allowed for namespace purposes but
|
|
otherwise ignored.
|
|
|
|
"""
|
|
orig_line = line
|
|
xfail = False
|
|
if line.startswith('xfail-'):
|
|
xfail = True
|
|
line = line[len('xfail-'):]
|
|
else:
|
|
match = re.match(r'xfail\[(.*?)\]-(.*)', line)
|
|
if match:
|
|
xfail_cond = match.group(1)
|
|
line = match.group(2)
|
|
# "xfail[cond]-" or "xfail[cond1|cond2|...]-" means a
|
|
# failure of the test is allowed if any of the listed
|
|
# conditions are in the --xfail command-line option
|
|
# argument.
|
|
if self.xfail_str and re.search(r'\b(%s)\b' % xfail_cond,
|
|
self.xfail_str):
|
|
xfail = True
|
|
optional = False
|
|
if line.startswith('optional-'):
|
|
optional = True
|
|
line = line[len('optional-'):]
|
|
# Tokens in test data are space-separated, except for {...}
|
|
# tokens that may contain spaces.
|
|
tokens = []
|
|
while line:
|
|
match = re.match(r'\{(.*?)\}(.*)', line)
|
|
if match:
|
|
tokens.append(match.group(1))
|
|
line = match.group(2)
|
|
else:
|
|
match = re.match(r'([^ ]*)(.*)', line)
|
|
tokens.append(match.group(1))
|
|
line = match.group(2)
|
|
line = line.strip()
|
|
if tokens[0] == 'allow-header':
|
|
if len(tokens) != 2 or xfail or optional:
|
|
raise ValueError('bad allow-header line: %s' % orig_line)
|
|
if tokens[1] not in self.headers_handled:
|
|
self.load_tests(tokens[1], True)
|
|
return
|
|
if tokens[0] == 'allow':
|
|
if len(tokens) != 2 or xfail or optional:
|
|
raise ValueError('bad allow line: %s' % orig_line)
|
|
self.add_allow(tokens[1], True)
|
|
return
|
|
test_classes = {'element': ElementTest,
|
|
'macro': ConstantTest,
|
|
'constant': ConstantTest,
|
|
'macro-constant': ConstantTest,
|
|
'macro-int-constant': ConstantTest,
|
|
'symbol': SymbolTest,
|
|
'type': TypeTest,
|
|
'tag': TagTest,
|
|
'function': FunctionTest,
|
|
'variable': VariableTest,
|
|
'macro-function': MacroFunctionTest,
|
|
'macro-str': MacroStrTest}
|
|
test = test_classes[tokens[0]](*tokens)
|
|
test.xfail = xfail
|
|
test.optional = optional
|
|
test.num = self.num_tests
|
|
test.subtests = []
|
|
self.num_tests += 1
|
|
self.add_allow(test.allow_name, False)
|
|
if not allow:
|
|
test.gen_subtests()
|
|
self.tests.append(test)
|
|
|
|
def load_tests(self, header, allow):
|
|
"""Load tests of a header.
|
|
|
|
If allow is true, the header is one specified in allow-header
|
|
and so tests are marked as allowed for namespace purposes but
|
|
otherwise ignored.
|
|
|
|
"""
|
|
self.headers_handled.add(header)
|
|
header_s = header.replace('/', '_')
|
|
temp_file = os.path.join(self.temp_dir, 'header-data-%s' % header_s)
|
|
cmd = ('%s -E -D%s -std=c99 -x c data/%s-data > %s'
|
|
% (self.cc, self.standard, header, temp_file))
|
|
subprocess.check_call(cmd, shell=True)
|
|
with open(temp_file, 'r') as tests:
|
|
for line in tests:
|
|
line = line.strip()
|
|
if line == '' or line.startswith('#'):
|
|
continue
|
|
self.handle_test_line(line, allow)
|
|
|
|
def note_error(self, name, xfail):
|
|
"""Note a failing test."""
|
|
if xfail:
|
|
print('XFAIL: %s' % name)
|
|
self.xerrors += 1
|
|
else:
|
|
print('FAIL: %s' % name)
|
|
self.errors += 1
|
|
sys.stdout.flush()
|
|
|
|
def note_skip(self, name):
|
|
"""Note a skipped test."""
|
|
print('SKIP: %s' % name)
|
|
self.skipped += 1
|
|
sys.stdout.flush()
|
|
|
|
def compile_test(self, name, text):
|
|
"""Run a compilation test; return True if it passes."""
|
|
self.total += 1
|
|
if self.group_ignore:
|
|
return False
|
|
optional = self.group_optional
|
|
self.group_optional = False
|
|
if self.group_skip:
|
|
self.note_skip(name)
|
|
return False
|
|
c_file = os.path.join(self.temp_dir, 'test.c')
|
|
o_file = os.path.join(self.temp_dir, 'test.o')
|
|
with open(c_file, 'w') as c_file_out:
|
|
c_file_out.write('#include <%s>\n%s' % (self.header, text))
|
|
cmd = ('%s %s -c %s -o %s' % (self.cc, self.cflags, c_file, o_file))
|
|
try:
|
|
subprocess.check_call(cmd, shell=True)
|
|
except subprocess.CalledProcessError:
|
|
if optional:
|
|
print('MISSING: %s' % name)
|
|
sys.stdout.flush()
|
|
self.group_ignore = True
|
|
else:
|
|
self.note_error(name, self.group_xfail)
|
|
self.group_skip = True
|
|
return False
|
|
print('PASS: %s' % name)
|
|
sys.stdout.flush()
|
|
return True
|
|
|
|
def execute_test(self, name, text):
|
|
"""Run an execution test."""
|
|
self.total += 1
|
|
if self.group_ignore:
|
|
return False
|
|
if self.group_skip:
|
|
self.note_skip(name)
|
|
return
|
|
c_file = os.path.join(self.temp_dir, 'test.c')
|
|
exe_file = os.path.join(self.temp_dir, 'test')
|
|
with open(c_file, 'w') as c_file_out:
|
|
c_file_out.write('#include <%s>\n%s' % (self.header, text))
|
|
cmd = ('%s %s %s -o %s' % (self.cc, self.cflags, c_file, exe_file))
|
|
try:
|
|
subprocess.check_call(cmd, shell=True)
|
|
except subprocess.CalledProcessError:
|
|
self.note_error(name, self.group_xfail)
|
|
return
|
|
if self.cross:
|
|
self.note_skip(name)
|
|
return
|
|
try:
|
|
subprocess.check_call(exe_file, shell=True)
|
|
except subprocess.CalledProcessError:
|
|
self.note_error(name, self.group_xfail)
|
|
return
|
|
print('PASS: %s' % name)
|
|
sys.stdout.flush()
|
|
|
|
def check_namespace(self, name):
|
|
"""Check the namespace of a header."""
|
|
c_file = os.path.join(self.temp_dir, 'namespace.c')
|
|
out_file = os.path.join(self.temp_dir, 'namespace-out')
|
|
with open(c_file, 'w') as c_file_out:
|
|
c_file_out.write('#include <%s>\n' % self.header)
|
|
cmd = ('%s %s -E %s -P -Wp,-dN > %s'
|
|
% (self.cc, self.cflags_namespace, c_file, out_file))
|
|
subprocess.check_call(cmd, shell=True)
|
|
bad_tokens = set()
|
|
with open(out_file, 'r') as content:
|
|
for line in content:
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
if re.match(r'# [1-9]', line):
|
|
continue
|
|
match = re.match(r'#define (.*)', line)
|
|
if match:
|
|
self.check_token(bad_tokens, match.group(1))
|
|
continue
|
|
match = re.match(r'#undef (.*)', line)
|
|
if match:
|
|
bad_tokens.discard(match.group(1))
|
|
continue
|
|
# Tokenize the line and check identifiers found. The
|
|
# handling of strings does not allow for escaped
|
|
# quotes, no allowance is made for character
|
|
# constants, and hex floats may be wrongly split into
|
|
# tokens including identifiers, but this is sufficient
|
|
# in practice and matches the old perl script.
|
|
line = re.sub(r'"[^"]*"', '', line)
|
|
line = line.strip()
|
|
for token in re.split(r'[^A-Za-z0-9_]+', line):
|
|
if re.match(r'[A-Za-z_]', token):
|
|
self.check_token(bad_tokens, token)
|
|
if bad_tokens:
|
|
for token in sorted(bad_tokens):
|
|
print(' Namespace violation: "%s"' % token)
|
|
self.note_error(name, False)
|
|
else:
|
|
print('PASS: %s' % name)
|
|
sys.stdout.flush()
|
|
|
|
def run(self):
|
|
"""Load and run tests of a header."""
|
|
with tempfile.TemporaryDirectory() as self.temp_dir:
|
|
self.load_tests(self.header, False)
|
|
self.group_optional = False
|
|
self.group_xfail = False
|
|
self.group_ignore = False
|
|
self.group_skip = False
|
|
available = self.compile_test('Availability of <%s>' % self.header,
|
|
'')
|
|
if available:
|
|
# As an optimization, try running all non-optional,
|
|
# non-XFAILed compilation tests in a single execution
|
|
# of the compiler.
|
|
combined_list = []
|
|
for test in self.tests:
|
|
if not test.optional and not test.xfail:
|
|
for subtest in test.subtests:
|
|
if isinstance(subtest, CompileSubTest):
|
|
combined_list.append(subtest.text)
|
|
subtest.run_early = True
|
|
combined_ok = self.compile_test('Combined <%s> test'
|
|
% self.header,
|
|
'\n'.join(combined_list))
|
|
# Now run the other tests, or all tests if the
|
|
# combined test failed.
|
|
for test in self.tests:
|
|
# A test may run more than one subtest. If the
|
|
# initial subtest for an optional symbol fails,
|
|
# others are not run at all; if the initial
|
|
# subtest for an optional symbol succeeds, others
|
|
# are run and are not considered optional; if the
|
|
# initial subtest for a required symbol fails,
|
|
# others are skipped.
|
|
self.group_optional = test.optional
|
|
self.group_xfail = test.xfail
|
|
self.group_ignore = False
|
|
self.group_skip = False
|
|
for subtest in test.subtests:
|
|
if combined_ok and subtest.run_early:
|
|
self.total += 1
|
|
print('PASSCOMBINED: %s' % subtest.name)
|
|
sys.stdout.flush()
|
|
else:
|
|
subtest.run(self)
|
|
namespace_name = 'Namespace of <%s>' % self.header
|
|
if available:
|
|
self.check_namespace(namespace_name)
|
|
else:
|
|
self.note_skip(namespace_name)
|
|
print('-' * 76)
|
|
print(' Total number of tests : %4d' % self.total)
|
|
print(' Number of failed tests : %4d' % self.errors)
|
|
print(' Number of xfailed tests : %4d' % self.xerrors)
|
|
print(' Number of skipped tests : %4d' % self.skipped)
|
|
sys.exit(1 if self.errors else 0)
|
|
|
|
|
|
def main():
|
|
"""The main entry point."""
|
|
parser = argparse.ArgumentParser(description='Check header contents.')
|
|
parser.add_argument('--header', metavar='HEADER',
|
|
help='name of header')
|
|
parser.add_argument('--standard', metavar='STD',
|
|
help='standard to use when processing header')
|
|
parser.add_argument('--cc', metavar='CC',
|
|
help='C compiler to use')
|
|
parser.add_argument('--flags', metavar='CFLAGS',
|
|
help='Compiler flags to use with CC')
|
|
parser.add_argument('--cross', action='store_true',
|
|
help='Do not run compiled test programs')
|
|
parser.add_argument('--xfail', metavar='COND',
|
|
help='Name of condition for XFAILs')
|
|
args = parser.parse_args()
|
|
tests = HeaderTests(args.header, args.standard, args.cc, args.flags,
|
|
args.cross, args.xfail)
|
|
tests.run()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|