yuzu-emu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-11-26 08:45:40 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fix style errors reported by pylint

Browse Source
This commit is contained in:
Azim Khan 2018-07-03 11:57:54 +01:00 committed by Mohammad Azim Khan
parent aee05bbe70
commit b31aa44e16
3 changed files with 883 additions and 641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

493
tests/scripts/generate_test_code.py
View File

@ -16,7 +16,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This file is part of mbed TLS (https://tls.mbed.org)
# This file is part of Mbed TLS (https://tls.mbed.org)
"""
This script is a key part of Mbed TLS test suites framework. For
@ -29,7 +29,7 @@ Mbed TLS test suites:
Scope:
------
The test suites focus on unit testing the crypto primitives and also
include x509 parser tests. Tests can be added to test any MBED TLS
include x509 parser tests. Tests can be added to test any Mbed TLS
module. However, the framework is not capable of testing SSL
protocol, since that requires full stack execution and that is best
tested as part of the system test.
@ -59,7 +59,8 @@ as an expression. Following is an example test definition:
X509 CRL Unsupported critical extension (issuingDistributionPoint)
depends_on:MBEDTLS_PEM_PARSE_C:MBEDTLS_RSA_C:MBEDTLS_SHA256_C
mbedtls_x509_crl_parse:"data_files/crl-idp.pem":MBEDTLS_ERR_X509_INVALID_EXTENSIONS + MBEDTLS_ERR_ASN1_UNEXPECTED_TAG
mbedtls_x509_crl_parse:"data_files/crl-idp.pem":\
MBEDTLS_ERR_X509_INVALID_EXTENSIONS + MBEDTLS_ERR_ASN1_UNEXPECTED_TAG
Test functions:
---------------
@ -170,17 +171,17 @@ import sys
import argparse
BEGIN_HEADER_REGEX = '/\*\s*BEGIN_HEADER\s*\*/'
END_HEADER_REGEX = '/\*\s*END_HEADER\s*\*/'
BEGIN_HEADER_REGEX = r'/\*\s*BEGIN_HEADER\s*\*/'
END_HEADER_REGEX = r'/\*\s*END_HEADER\s*\*/'
BEGIN_SUITE_HELPERS_REGEX = '/\*\s*BEGIN_SUITE_HELPERS\s*\*/'
END_SUITE_HELPERS_REGEX = '/\*\s*END_SUITE_HELPERS\s*\*/'
BEGIN_SUITE_HELPERS_REGEX = r'/\*\s*BEGIN_SUITE_HELPERS\s*\*/'
END_SUITE_HELPERS_REGEX = r'/\*\s*END_SUITE_HELPERS\s*\*/'
BEGIN_DEP_REGEX = 'BEGIN_DEPENDENCIES'
END_DEP_REGEX = 'END_DEPENDENCIES'
BEGIN_DEP_REGEX = r'BEGIN_DEPENDENCIES'
END_DEP_REGEX = r'END_DEPENDENCIES'
BEGIN_CASE_REGEX = '/\*\s*BEGIN_CASE\s*(.*?)\s*\*/'
END_CASE_REGEX = '/\*\s*END_CASE\s*\*/'
BEGIN_CASE_REGEX = r'/\*\s*BEGIN_CASE\s*(.*?)\s*\*/'
END_CASE_REGEX = r'/\*\s*END_CASE\s*\*/'
class GeneratorInputError(Exception):
@ -192,7 +193,7 @@ class GeneratorInputError(Exception):
pass
class FileWrapper(io.FileIO):
class FileWrapper(io.FileIO, object):
"""
This class extends built-in io.FileIO class with attribute line_no,
that indicates line number for the line that is read.
@ -205,9 +206,9 @@ class FileWrapper(io.FileIO):
:param file_name: File path to open.
"""
super(FileWrapper, self).__init__(file_name, 'r')
self.line_no = 0
self._line_no = 0
def __next__(self):
def next(self):
"""
Python 2 iterator method. This method overrides base class's
next method and extends the next method to count the line
@ -223,20 +224,28 @@ class FileWrapper(io.FileIO):
line = parent.__next__() # Python 3
else:
line = parent.next() # Python 2
if line:
self.line_no += 1
if line is not None:
self._line_no += 1
# Convert byte array to string with correct encoding and
# strip any whitespaces added in the decoding process.
return line.decode(sys.getdefaultencoding()).strip() + "\n"
return None
# Python 3 iterator method
next = __next__
__next__ = next
def get_line_no(self):
"""
Gives current line number.
"""
return self._line_no
line_no = property(get_line_no)
def split_dep(dep):
"""
Split NOT character '!' from dependency. Used by gen_deps()
Split NOT character '!' from dependency. Used by gen_dependencies()
:param dep: Dependency list
:return: string tuple. Ex: ('!', MACRO) for !MACRO and ('', MACRO) for
@ -245,7 +254,7 @@ def split_dep(dep):
return ('!', dep[1:]) if dep[0] == '!' else ('', dep)
def gen_deps(deps):
def gen_dependencies(dependencies):
"""
Test suite data and functions specifies compile time dependencies.
This function generates C preprocessor code from the input
@ -256,36 +265,39 @@ def gen_deps(deps):
function split_dep() and proper preprocessor check is generated
accordingly.
:param deps: List of dependencies.
:param dependencies: List of dependencies.
:return: if defined and endif code with macro annotations for
readability.
"""
dep_start = ''.join(['#if %sdefined(%s)\n' % split_dep(x) for x in deps])
dep_end = ''.join(['#endif /* %s */\n' % x for x in reversed(deps)])
dep_start = ''.join(['#if %sdefined(%s)\n' % (x, y) for x, y in
map(split_dep, dependencies)])
dep_end = ''.join(['#endif /* %s */\n' %
x for x in reversed(dependencies)])
return dep_start, dep_end
def gen_deps_one_line(deps):
def gen_dependencies_one_line(dependencies):
"""
Similar to gen_deps() but generates dependency checks in one line.
Similar to gen_dependencies() but generates dependency checks in one line.
Useful for generating code with #else block.
:param deps: List of dependencies.
:return: ifdef code
:param dependencies: List of dependencies.
:return: Preprocessor check code
"""
defines = '#if ' if len(deps) else ''
defines += ' && '.join(['%sdefined(%s)' % split_dep(x) for x in deps])
defines = '#if ' if dependencies else ''
defines += ' && '.join(['%sdefined(%s)' % (x, y) for x, y in map(
split_dep, dependencies)])
return defines
def gen_function_wrapper(name, locals, args_dispatch):
def gen_function_wrapper(name, local_vars, args_dispatch):
"""
Creates test function wrapper code. A wrapper has the code to
unpack parameters from parameters[] array.
:param name: Test function name
:param locals: Local variables declaration code
:param local_vars: Local variables declaration code
:param args_dispatch: List of dispatch arguments.
Ex: ['(char *)params[0]', '*((int *)params[1])']
:return: Test function wrapper.
@ -300,11 +312,11 @@ void {name}_wrapper( void ** params )
'''.format(name=name,
unused_params='' if args_dispatch else ' (void)params;\n',
args=', '.join(args_dispatch),
locals=locals)
locals=local_vars)
return wrapper
def gen_dispatch(name, deps):
def gen_dispatch(name, dependencies):
"""
Test suite code template main_test.function defines a C function
array to contain test case functions. This function generates an
@ -314,18 +326,18 @@ def gen_dispatch(name, deps):
dependencies are met, else NULL is assigned.
:param name: Test function name
:param deps: List of dependencies
:param dependencies: List of dependencies
:return: Dispatch code.
"""
if len(deps):
ifdef = gen_deps_one_line(deps)
if dependencies:
preprocessor_check = gen_dependencies_one_line(dependencies)
dispatch_code = '''
{ifdef}
{preprocessor_check}
{name}_wrapper,
#else
NULL,
#endif
'''.format(ifdef=ifdef, name=name)
'''.format(preprocessor_check=preprocessor_check, name=name)
else:
dispatch_code = '''
{name}_wrapper,
@ -355,7 +367,7 @@ def parse_until_pattern(funcs_f, end_regex):
return headers
def parse_suite_deps(funcs_f):
def parse_suite_dependencies(funcs_f):
"""
Parses test suite dependencies specified at the top of a
.function file, that starts with pattern BEGIN_DEPENDENCIES
@ -365,21 +377,22 @@ def parse_suite_deps(funcs_f):
:param funcs_f: file object for .functions file
:return: List of test suite dependencies.
"""
deps = []
dependencies = []
for line in funcs_f:
m = re.search('depends_on\:(.*)', line.strip())
if m:
deps += [x.strip() for x in m.group(1).split(':')]
match = re.search('depends_on:(.*)', line.strip())
if match:
dependencies += [x.strip() for x in match.group(1).split(':')]
if re.search(END_DEP_REGEX, line):
break
else:
raise GeneratorInputError("file: %s - end dependency pattern [%s]"
" not found!" % (funcs_f.name, END_DEP_REGEX))
" not found!" % (funcs_f.name,
END_DEP_REGEX))
return deps
return dependencies
def parse_function_deps(line):
def parse_function_dependencies(line):
"""
Parses function dependencies, that are in the same line as
comment BEGIN_CASE. Dependencies are specified after pattern
@ -388,14 +401,15 @@ def parse_function_deps(line):
:param line: Line from .functions file that has dependencies.
:return: List of dependencies.
"""
deps = []
m = re.search(BEGIN_CASE_REGEX, line)
dep_str = m.group(1)
if len(dep_str):
m = re.search('depends_on:(.*)', dep_str)
if m:
deps = [x.strip() for x in m.group(1).strip().split(':')]
return deps
dependencies = []
match = re.search(BEGIN_CASE_REGEX, line)
dep_str = match.group(1)
if dep_str:
match = re.search('depends_on:(.*)', dep_str)
if match:
dependencies = [x.strip()
for x in match.group(1).strip().split(':')]
return dependencies
def parse_function_signature(line):
@ -410,31 +424,31 @@ def parse_function_signature(line):
wrapper function and argument dispatch code.
"""
args = []
locals = ''
local_vars = ''
args_dispatch = []
# Check if the test function returns void.
m = re.search('\s*void\s+(\w+)\s*\(', line, re.I)
if not m:
match = re.search(r'\s*void\s+(\w+)\s*\(', line, re.I)
if not match:
raise ValueError("Test function should return 'void'\n%s" % line)
name = m.group(1)
line = line[len(m.group(0)):]
name = match.group(1)
line = line[len(match.group(0)):]
arg_idx = 0
for arg in line[:line.find(')')].split(','):
arg = arg.strip()
if arg == '':
continue
if re.search('int\s+.*', arg.strip()):
if re.search(r'int\s+.*', arg.strip()):
args.append('int')
args_dispatch.append('*( (int *) params[%d] )' % arg_idx)
elif re.search('char\s*\*\s*.*', arg.strip()):
elif re.search(r'char\s*\*\s*.*', arg.strip()):
args.append('char*')
args_dispatch.append('(char *) params[%d]' % arg_idx)
elif re.search('data_t\s*\*\s*.*', arg.strip()):
elif re.search(r'data_t\s*\*\s*.*', arg.strip()):
args.append('hex')
# create a structure
pointer_initializer = '(uint8_t *) params[%d]' % arg_idx
len_initializer = '*( (uint32_t *) params[%d] )' % (arg_idx+1)
locals += """ data_t data%d = {%s, %s};
local_vars += """ data_t data%d = {%s, %s};
""" % (arg_idx, pointer_initializer, len_initializer)
args_dispatch.append('&data%d' % arg_idx)
@ -444,31 +458,32 @@ def parse_function_signature(line):
"'char *' or 'data_t'\n%s" % line)
arg_idx += 1
return name, args, locals, args_dispatch
return name, args, local_vars, args_dispatch
def parse_function_code(funcs_f, deps, suite_deps):
def parse_function_code(funcs_f, dependencies, suite_dependencies):
"""
Parses out a function from function file object and generates
function and dispatch code.
:param funcs_f: file object of the functions file.
:param deps: List of dependencies
:param suite_deps: List of test suite dependencies
:param dependencies: List of dependencies
:param suite_dependencies: List of test suite dependencies
:return: Function name, arguments, function code and dispatch code.
"""
code = '#line %d "%s"\n' % (funcs_f.line_no + 1, funcs_f.name)
for line in funcs_f:
# Check function signature
m = re.match('.*?\s+(\w+)\s*\(', line, re.I)
if m:
match = re.match(r'.*?\s+(\w+)\s*\(', line, re.I)
if match:
# check if we have full signature i.e. split in more lines
if not re.match('.*\)', line):
if not re.match(r'.*\)', line):
for lin in funcs_f:
line += lin
if re.search('.*?\)', line):
if re.search(r'.*?\)', line):
break
name, args, locals, args_dispatch = parse_function_signature(line)
name, args, local_vars, args_dispatch = parse_function_signature(
line)
code += line.replace(name, 'test_' + name)
name = 'test_' + name
break
@ -486,16 +501,18 @@ def parse_function_code(funcs_f, deps, suite_deps):
# Add exit label if not present
if code.find('exit:') == -1:
s = code.rsplit('}', 1)
if len(s) == 2:
split_code = code.rsplit('}', 1)
if len(split_code) == 2:
code = """exit:
;;
}""".join(s)
}""".join(split_code)
code += gen_function_wrapper(name, locals, args_dispatch)
ifdef, endif = gen_deps(deps)
dispatch_code = gen_dispatch(name, suite_deps + deps)
return name, args, ifdef + code + endif, dispatch_code
code += gen_function_wrapper(name, local_vars, args_dispatch)
preprocessor_check_start, preprocessor_check_end = \
gen_dependencies(dependencies)
dispatch_code = gen_dispatch(name, suite_dependencies + dependencies)
return (name, args, preprocessor_check_start + code +
preprocessor_check_end, dispatch_code)
def parse_functions(funcs_f):
@ -508,9 +525,8 @@ def parse_functions(funcs_f):
code, function code and a dict with function identifiers
and arguments info.
"""
suite_headers = ''
suite_helpers = ''
suite_deps = []
suite_dependencies = []
suite_functions = ''
func_info = {}
function_idx = 0
@ -518,62 +534,61 @@ def parse_functions(funcs_f):
for line in funcs_f:
if re.search(BEGIN_HEADER_REGEX, line):
headers = parse_until_pattern(funcs_f, END_HEADER_REGEX)
suite_headers += headers
suite_helpers += headers
elif re.search(BEGIN_SUITE_HELPERS_REGEX, line):
helpers = parse_until_pattern(funcs_f, END_SUITE_HELPERS_REGEX)
suite_helpers += helpers
elif re.search(BEGIN_DEP_REGEX, line):
deps = parse_suite_deps(funcs_f)
suite_deps += deps
suite_dependencies += parse_suite_dependencies(funcs_f)
elif re.search(BEGIN_CASE_REGEX, line):
deps = parse_function_deps(line)
dependencies = parse_function_dependencies(line)
func_name, args, func_code, func_dispatch =\
parse_function_code(funcs_f, deps, suite_deps)
parse_function_code(funcs_f, dependencies, suite_dependencies)
suite_functions += func_code
# Generate dispatch code and enumeration info
if func_name in func_info:
raise GeneratorInputError(
"file: %s - function %s re-declared at line %d" % \
"file: %s - function %s re-declared at line %d" %
(funcs_f.name, func_name, funcs_f.line_no))
func_info[func_name] = (function_idx, args)
dispatch_code += '/* Function Id: %d */\n' % function_idx
dispatch_code += func_dispatch
function_idx += 1
ifdef, endif = gen_deps(suite_deps)
func_code = ifdef + suite_headers + suite_helpers + suite_functions + endif
return suite_deps, dispatch_code, func_code, func_info
func_code = (suite_helpers +
suite_functions).join(gen_dependencies(suite_dependencies))
return suite_dependencies, dispatch_code, func_code, func_info
def escaped_split(str, ch):
def escaped_split(inp_str, split_char):
"""
Split str on character ch but ignore escaped \{ch}
Split inp_str on character split_char but ignore if escaped.
Since, return value is used to write back to the intermediate
data file, any escape characters in the input are retained in the
output.
:param str: String to split
:param ch: split character
:param inp_str: String to split
:param split_char: split character
:return: List of splits
"""
if len(ch) > 1:
if len(split_char) > 1:
raise ValueError('Expected split character. Found string!')
out = []
part = ''
escape = False
for i in range(len(str)):
if not escape and str[i] == ch:
for character in inp_str:
if not escape and character == split_char:
out.append(part)
part = ''
else:
part += str[i]
escape = not escape and str[i] == '\\'
if len(part):
part += character
escape = not escape and character == '\\'
if part:
out.append(part)
return out
def parse_test_data(data_f, debug=False):
def parse_test_data(data_f):
"""
Parses .data file for each test case name, test function name,
test dependencies and test arguments. This information is
@ -587,44 +602,44 @@ def parse_test_data(data_f, debug=False):
:return: Generator that yields test name, function name,
dependency list and function argument list.
"""
STATE_READ_NAME = 0
STATE_READ_ARGS = 1
state = STATE_READ_NAME
deps = []
__state_read_name = 0
__state_read_args = 1
state = __state_read_name
dependencies = []
name = ''
for line in data_f:
line = line.strip()
if len(line) and line[0] == '#': # Skip comments
if line and line[0] == '#': # Skip comments
continue
# Blank line indicates end of test
if len(line) == 0:
if state == STATE_READ_ARGS:
if not line:
if state == __state_read_args:
raise GeneratorInputError("[%s:%d] Newline before arguments. "
"Test function and arguments "
"missing for %s" %
(data_f.name, data_f.line_no, name))
continue
if state == STATE_READ_NAME:
if state == __state_read_name:
# Read test name
name = line
state = STATE_READ_ARGS
elif state == STATE_READ_ARGS:
state = __state_read_args
elif state == __state_read_args:
# Check dependencies
m = re.search('depends_on\:(.*)', line)
if m:
deps = [x.strip() for x in m.group(1).split(':') if len(
x.strip())]
match = re.search('depends_on:(.*)', line)
if match:
dependencies = [x.strip() for x in match.group(1).split(':')
if len(x.strip())]
else:
# Read test vectors
parts = escaped_split(line, ':')
function = parts[0]
test_function = parts[0]
args = parts[1:]
yield name, function, deps, args
deps = []
state = STATE_READ_NAME
if state == STATE_READ_ARGS:
yield name, test_function, dependencies, args
dependencies = []
state = __state_read_name
if state == __state_read_args:
raise GeneratorInputError("[%s:%d] Newline before arguments. "
"Test function and arguments missing for "
"%s" % (data_f.name, data_f.line_no, name))
@ -642,19 +657,19 @@ def gen_dep_check(dep_id, dep):
if dep_id < 0:
raise GeneratorInputError("Dependency Id should be a positive "
"integer.")
noT, dep = ('!', dep[1:]) if dep[0] == '!' else ('', dep)
if len(dep) == 0:
_not, dep = ('!', dep[1:]) if dep[0] == '!' else ('', dep)
if not dep:
raise GeneratorInputError("Dependency should not be an empty string.")
dep_check = '''
case {id}:
{{
#if {noT}defined({macro})
#if {_not}defined({macro})
ret = DEPENDENCY_SUPPORTED;
#else
ret = DEPENDENCY_NOT_SUPPORTED;
#endif
}}
break;'''.format(noT=noT, macro=dep, id=dep_id)
break;'''.format(_not=_not, macro=dep, id=dep_id)
return dep_check
@ -670,7 +685,7 @@ def gen_expression_check(exp_id, exp):
if exp_id < 0:
raise GeneratorInputError("Expression Id should be a positive "
"integer.")
if len(exp) == 0:
if not exp:
raise GeneratorInputError("Expression should not be an empty string.")
exp_code = '''
case {exp_id}:
@ -681,28 +696,28 @@ def gen_expression_check(exp_id, exp):
return exp_code
def write_deps(out_data_f, test_deps, unique_deps):
def write_dependencies(out_data_f, test_dependencies, unique_dependencies):
"""
Write dependencies to intermediate test data file, replacing
the string form with identifiers. Also, generates dependency
check code.
:param out_data_f: Output intermediate data file
:param test_deps: Dependencies
:param unique_deps: Mutable list to track unique dependencies
:param test_dependencies: Dependencies
:param unique_dependencies: Mutable list to track unique dependencies
that are global to this re-entrant function.
:return: returns dependency check code.
"""
dep_check_code = ''
if len(test_deps):
if test_dependencies:
out_data_f.write('depends_on')
for dep in test_deps:
if dep not in unique_deps:
unique_deps.append(dep)
dep_id = unique_deps.index(dep)
for dep in test_dependencies:
if dep not in unique_dependencies:
unique_dependencies.append(dep)
dep_id = unique_dependencies.index(dep)
dep_check_code += gen_dep_check(dep_id, dep)
else:
dep_id = unique_deps.index(dep)
dep_id = unique_dependencies.index(dep)
out_data_f.write(':' + str(dep_id))
out_data_f.write('\n')
return dep_check_code
@ -722,12 +737,12 @@ def write_parameters(out_data_f, test_args, func_args, unique_expressions):
:return: Returns expression check code.
"""
expression_code = ''
for i in range(len(test_args)):
for i, _ in enumerate(test_args):
typ = func_args[i]
val = test_args[i]
# check if val is a non literal int val (i.e. an expression)
if typ == 'int' and not re.match('(\d+$)|((0x)?[0-9a-fA-F]+$)', val):
if typ == 'int' and not re.match(r'(\d+$)|((0x)?[0-9a-fA-F]+$)', val):
typ = 'exp'
if val not in unique_expressions:
unique_expressions.append(val)
@ -744,33 +759,33 @@ def write_parameters(out_data_f, test_args, func_args, unique_expressions):
return expression_code
def gen_suite_deps_checks(suite_deps, dep_check_code, expression_code):
def gen_suite_dep_checks(suite_dependencies, dep_check_code, expression_code):
"""
Generates preprocessor checks for test suite dependencies.
:param suite_deps: Test suite dependencies read from the
:param suite_dependencies: Test suite dependencies read from the
.functions file.
:param dep_check_code: Dependency check code
:param expression_code: Expression check code
:return: Dependency and expression code guarded by test suite
dependencies.
"""
if len(suite_deps):
ifdef = gen_deps_one_line(suite_deps)
if suite_dependencies:
preprocessor_check = gen_dependencies_one_line(suite_dependencies)
dep_check_code = '''
{ifdef}
{preprocessor_check}
{code}
#endif
'''.format(ifdef=ifdef, code=dep_check_code)
'''.format(preprocessor_check=preprocessor_check, code=dep_check_code)
expression_code = '''
{ifdef}
{preprocessor_check}
{code}
#endif
'''.format(ifdef=ifdef, code=expression_code)
'''.format(preprocessor_check=preprocessor_check, code=expression_code)
return dep_check_code, expression_code
def gen_from_test_data(data_f, out_data_f, func_info, suite_deps):
def gen_from_test_data(data_f, out_data_f, func_info, suite_dependencies):
"""
This function reads test case name, dependencies and test vectors
from the .data file. This information is correlated with the test
@ -785,19 +800,20 @@ def gen_from_test_data(data_f, out_data_f, func_info, suite_deps):
:param out_data_f:Output intermediate data file
:param func_info: Dict keyed by function and with function id
and arguments info
:param suite_deps: Test suite deps
:param suite_dependencies: Test suite dependencies
:return: Returns dependency and expression check code
"""
unique_deps = []
unique_dependencies = []
unique_expressions = []
dep_check_code = ''
expression_code = ''
for test_name, function_name, test_deps, test_args in parse_test_data(
data_f):
for test_name, function_name, test_dependencies, test_args in \
parse_test_data(data_f):
out_data_f.write(test_name + '\n')
# Write deps
dep_check_code += write_deps(out_data_f, test_deps, unique_deps)
# Write dependencies
dep_check_code += write_dependencies(out_data_f, test_dependencies,
unique_dependencies)
# Write test function name
test_function_name = 'test_' + function_name
@ -810,46 +826,51 @@ def gen_from_test_data(data_f, out_data_f, func_info, suite_deps):
# Write parameters
if len(test_args) != len(func_args):
raise GeneratorInputError("Invalid number of arguments in test "
"%s. See function %s signature." % (
test_name, function_name))
"%s. See function %s signature." %
(test_name, function_name))
expression_code += write_parameters(out_data_f, test_args, func_args,
unique_expressions)
# Write a newline as test case separator
out_data_f.write('\n')
dep_check_code, expression_code = gen_suite_deps_checks(
suite_deps, dep_check_code, expression_code)
dep_check_code, expression_code = gen_suite_dep_checks(
suite_dependencies, dep_check_code, expression_code)
return dep_check_code, expression_code
def generate_code(funcs_file, data_file, template_file, platform_file,
helpers_file, suites_dir, c_file, out_data_file):
def add_input_info(funcs_file, data_file, template_file,
c_file, snippets):
"""
Generates C source code from test suite file, data file, common
helpers file and platform file.
Add generator input info in snippets.
:param funcs_file: Functions file object
:param data_file: Data file object
:param template_file: Template file object
:param platform_file: Platform file object
:param helpers_file: Helper functions file object
:param suites_dir: Test suites dir
:param c_file: Output C file object
:param out_data_file: Output intermediate data file object
:param snippets: Dictionary to contain code pieces to be
substituted in the template.
:return:
"""
for name, path in [('Functions file', funcs_file),
('Data file', data_file),
('Template file', template_file),
('Platform file', platform_file),
('Helpers code file', helpers_file),
('Suites dir', suites_dir)]:
if not os.path.exists(path):
raise IOError("ERROR: %s [%s] not found!" % (name, path))
snippets['test_file'] = c_file
snippets['test_main_file'] = template_file
snippets['test_case_file'] = funcs_file
snippets['test_case_data_file'] = data_file
snippets = {'generator_script' : os.path.basename(__file__)}
def read_code_from_input_files(platform_file, helpers_file,
out_data_file, snippets):
"""
Read code from input files and create substitutions for replacement
strings in the template file.
:param platform_file: Platform file object
:param helpers_file: Helper functions file object
:param out_data_file: Output intermediate data file object
:param snippets: Dictionary to contain code pieces to be
substituted in the template.
:return:
"""
# Read helpers
with open(helpers_file, 'r') as help_f, open(platform_file, 'r') as \
platform_f:
@ -859,25 +880,16 @@ def generate_code(funcs_file, data_file, template_file, platform_file,
snippets['platform_code'] = platform_f.read().replace(
'DATA_FILE', out_data_file.replace('\\', '\\\\')) # escape '\'
# Function code
with FileWrapper(funcs_file) as funcs_f, FileWrapper(data_file) as \
data_f, open(out_data_file, 'w') as out_data_f:
suite_deps, dispatch_code, func_code, func_info = parse_functions(
funcs_f)
snippets['functions_code'] = func_code
snippets['dispatch_code'] = dispatch_code
dep_check_code, expression_code = gen_from_test_data(
data_f, out_data_f, func_info, suite_deps)
snippets['dep_check_code'] = dep_check_code
snippets['expression_code'] = expression_code
snippets['test_file'] = c_file
snippets['test_main_file'] = template_file
snippets['test_case_file'] = funcs_file
snippets['test_case_data_file'] = data_file
# Read Template
# Add functions
#
def write_test_source_file(template_file, c_file, snippets):
"""
Write output source file with generated source code.
:param template_file: Template file name
:param c_file: Output source file
:param snippets: Generated and code snippets
:return:
"""
with open(template_file, 'r') as template_f, open(c_file, 'w') as c_f:
line_no = 1
for line in template_f.readlines():
@ -888,6 +900,89 @@ def generate_code(funcs_file, data_file, template_file, platform_file,
line_no += 1
def parse_function_file(funcs_file, snippets):
"""
Parse function file and generate function dispatch code.
:param funcs_file: Functions file name
:param snippets: Dictionary to contain code pieces to be
substituted in the template.
:return:
"""
with FileWrapper(funcs_file) as funcs_f:
suite_dependencies, dispatch_code, func_code, func_info = \
parse_functions(funcs_f)
snippets['functions_code'] = func_code
snippets['dispatch_code'] = dispatch_code
return suite_dependencies, func_info
def generate_intermediate_data_file(data_file, out_data_file,
suite_dependencies, func_info, snippets):
"""
Generates intermediate data file from input data file and
information read from functions file.
:param data_file: Data file name
:param out_data_file: Output/Intermediate data file
:param suite_dependencies: List of suite dependencies.
:param func_info: Function info parsed from functions file.
:param snippets: Dictionary to contain code pieces to be
substituted in the template.
:return:
"""
with FileWrapper(data_file) as data_f, \
open(out_data_file, 'w') as out_data_f:
dep_check_code, expression_code = gen_from_test_data(
data_f, out_data_f, func_info, suite_dependencies)
snippets['dep_check_code'] = dep_check_code
snippets['expression_code'] = expression_code
def generate_code(**input_info):
"""
Generates C source code from test suite file, data file, common
helpers file and platform file.
input_info expands to following parameters:
funcs_file: Functions file object
data_file: Data file object
template_file: Template file object
platform_file: Platform file object
helpers_file: Helper functions file object
suites_dir: Test suites dir
c_file: Output C file object
out_data_file: Output intermediate data file object
:return:
"""
funcs_file = input_info['funcs_file']
data_file = input_info['data_file']
template_file = input_info['template_file']
platform_file = input_info['platform_file']
helpers_file = input_info['helpers_file']
suites_dir = input_info['suites_dir']
c_file = input_info['c_file']
out_data_file = input_info['out_data_file']
for name, path in [('Functions file', funcs_file),
('Data file', data_file),
('Template file', template_file),
('Platform file', platform_file),
('Helpers code file', helpers_file),
('Suites dir', suites_dir)]:
if not os.path.exists(path):
raise IOError("ERROR: %s [%s] not found!" % (name, path))
snippets = {'generator_script': os.path.basename(__file__)}
read_code_from_input_files(platform_file, helpers_file,
out_data_file, snippets)
add_input_info(funcs_file, data_file, template_file,
c_file, snippets)
suite_dependencies, func_info = parse_function_file(funcs_file, snippets)
generate_intermediate_data_file(data_file, out_data_file,
suite_dependencies, func_info, snippets)
write_test_source_file(template_file, c_file, snippets)
def check_cmd():
"""
Command line parser.
@ -949,18 +1044,20 @@ def check_cmd():
out_c_file_dir = os.path.dirname(out_c_file)
out_data_file_dir = os.path.dirname(out_data_file)
for d in [out_c_file_dir, out_data_file_dir]:
if not os.path.exists(d):
os.makedirs(d)
for directory in [out_c_file_dir, out_data_file_dir]:
if not os.path.exists(directory):
os.makedirs(directory)
generate_code(args.funcs_file, args.data_file, args.template_file,
args.platform_file, args.helpers_file, args.suites_dir,
out_c_file, out_data_file)
generate_code(funcs_file=args.funcs_file, data_file=args.data_file,
template_file=args.template_file,
platform_file=args.platform_file,
helpers_file=args.helpers_file, suites_dir=args.suites_dir,
c_file=out_c_file, out_data_file=out_data_file)
if __name__ == "__main__":
try:
check_cmd()
except GeneratorInputError as e:
script_name = os.path.basename(sys.argv[0])
print("%s: input error: %s" % (script_name, str(e)))
except GeneratorInputError as err:
print("%s: input error: %s" %
(os.path.basename(sys.argv[0]), str(err)))

187
tests/scripts/mbedtls_test.py
View File

@ -15,18 +15,18 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This file is part of mbed TLS (https://tls.mbed.org)
# This file is part of Mbed TLS (https://tls.mbed.org)
"""
Mbed TLS on-target test suite tests are implemented as mbed-os greentea
Mbed TLS on-target test suite tests are implemented as mbed-os Greentea
tests. Greentea tests are implemented in two parts: target test and
host test. Target test is a C application that is built for the
target platform and executes on the target. Host test is a Python
class derived from mbed_host_tests.BaseHostTest. Target communicates
with the host over serial for the test data.
Python tool mbedgt (greentea) is responsible for flashing the test
Python tool mbedgt (Greentea) is responsible for flashing the test
binary on to the target and dynamically loading the host test.
This script contains the host test for handling target test's
@ -64,67 +64,69 @@ class TestDataParser(object):
:param data_file: Data file path
"""
with open(data_file, 'r') as f:
self.__parse(f)
with open(data_file, 'r') as data_f:
self.__parse(data_f)
@staticmethod
def __escaped_split(str, ch):
def __escaped_split(inp_str, split_char):
"""
Splits str on ch except when escaped.
Splits inp_str on split_char except when escaped.
:param str: String to split
:param ch: Split character
:param inp_str: String to split
:param split_char: Split character
:return: List of splits
"""
if len(ch) > 1:
if len(split_char) > 1:
raise ValueError('Expected split character. Found string!')
out = []
part = ''
escape = False
for i in range(len(str)):
if not escape and str[i] == ch:
for character in inp_str:
if not escape and character == split_char:
out.append(part)
part = ''
else:
part += str[i]
escape = not escape and str[i] == '\\'
if len(part):
part += character
escape = not escape and character == '\\'
if part:
out.append(part)
return out
def __parse(self, file):
def __parse(self, data_f):
"""
Parses data file using supplied file object.
:param file: Data file object
:param data_f: Data file object
:return:
"""
for line in file:
for line in data_f:
line = line.strip()
if len(line) == 0:
if not line:
continue
# Read test name
name = line
# Check dependencies
deps = []
line = file.next().strip()
m = re.search('depends_on\:(.*)', line)
if m:
deps = [int(x) for x in m.group(1).split(':')]
line = file.next().strip()
dependencies = []
line = data_f.next().strip()
match = re.search('depends_on:(.*)', line)
if match:
dependencies = [int(x) for x in match.group(1).split(':')]
line = data_f.next().strip()
# Read test vectors
line = line.replace('\\n', '\n')
parts = self.__escaped_split(line, ':')
function = int(parts[0])
x = parts[1:]
l = len(x)
if l % 2 != 0:
function_name = int(parts[0])
args = parts[1:]
args_count = len(args)
if args_count % 2 != 0:
raise TestDataParserError("Number of test arguments should "
"be even: %s" % line)
args = [(x[i * 2], x[(i * 2) + 1]) for i in range(len(x)/2)]
self.tests.append((name, function, deps, args))
grouped_args = [(args[i * 2], args[(i * 2) + 1])
for i in range(len(args)/2)]
self.tests.append((name, function_name, dependencies,
grouped_args))
def get_test_data(self):
"""
@ -135,8 +137,8 @@ class TestDataParser(object):
class MbedTlsTest(BaseHostTest):
"""
Host test for mbedtls unit tests. This script is loaded at
run time by Greentea for executing mbedtls test suites. Each
Host test for Mbed TLS unit tests. This script is loaded at
run time by Greentea for executing Mbed TLS test suites. Each
communication from the target is received in this object as
an event, which is then handled by the event handler method
decorated by the associated event. Ex: @event_callback('GO').
@ -144,7 +146,7 @@ class MbedTlsTest(BaseHostTest):
Target test sends requests for dispatching next test. It reads
tests from the intermediate data file and sends test function
identifier, dependency identifiers, expression identifiers and
the test data in binary form. Target test checks dependecnies
the test data in binary form. Target test checks dependencies
, evaluate integer constant expressions and dispatches the test
function with received test parameters.
@ -169,12 +171,18 @@ class MbedTlsTest(BaseHostTest):
self.test_index = -1
self.dep_index = 0
self.error_str = dict()
self.error_str[self.DEPENDENCY_SUPPORTED] = 'DEPENDENCY_SUPPORTED'
self.error_str[self.KEY_VALUE_MAPPING_NOT_FOUND] = 'KEY_VALUE_MAPPING_NOT_FOUND'
self.error_str[self.DEPENDENCY_NOT_SUPPORTED] = 'DEPENDENCY_NOT_SUPPORTED'
self.error_str[self.DISPATCH_TEST_FN_NOT_FOUND] = 'DISPATCH_TEST_FN_NOT_FOUND'
self.error_str[self.DISPATCH_INVALID_TEST_DATA] = 'DISPATCH_INVALID_TEST_DATA'
self.error_str[self.DISPATCH_UNSUPPORTED_SUITE] = 'DISPATCH_UNSUPPORTED_SUITE'
self.error_str[self.DEPENDENCY_SUPPORTED] = \
'DEPENDENCY_SUPPORTED'
self.error_str[self.KEY_VALUE_MAPPING_NOT_FOUND] = \
'KEY_VALUE_MAPPING_NOT_FOUND'
self.error_str[self.DEPENDENCY_NOT_SUPPORTED] = \
'DEPENDENCY_NOT_SUPPORTED'
self.error_str[self.DISPATCH_TEST_FN_NOT_FOUND] = \
'DISPATCH_TEST_FN_NOT_FOUND'
self.error_str[self.DISPATCH_INVALID_TEST_DATA] = \
'DISPATCH_INVALID_TEST_DATA'
self.error_str[self.DISPATCH_UNSUPPORTED_SUITE] = \
'DISPATCH_UNSUPPORTED_SUITE'
def setup(self):
"""
@ -206,13 +214,13 @@ class MbedTlsTest(BaseHostTest):
self.log('{{__testcase_name;%s}}' % name)
@staticmethod
def align_32bit(b):
def align_32bit(data_bytes):
"""
4 byte aligns input byte array.
:return:
"""
b += bytearray((4 - (len(b))) % 4)
data_bytes += bytearray((4 - (len(data_bytes))) % 4)
@staticmethod
def hex_str_bytes(hex_str):
@ -230,56 +238,56 @@ class MbedTlsTest(BaseHostTest):
raise TestDataParserError("HEX parameter len should be mod of "
"2: %s" % hex_str)
b = binascii.unhexlify(hex_str)
return b
data_bytes = binascii.unhexlify(hex_str)
return data_bytes
@staticmethod
def int32_to_bigendian_bytes(i):
def int32_to_big_endian_bytes(i):
"""
Coverts i to bytearray in big endian format.
Coverts i to byte array in big endian format.
:param i: Input integer
:return: Output bytes array in big endian or network order
"""
b = bytearray([((i >> x) & 0xff) for x in [24, 16, 8, 0]])
return b
data_bytes = bytearray([((i >> x) & 0xff) for x in [24, 16, 8, 0]])
return data_bytes
def test_vector_to_bytes(self, function_id, deps, parameters):
def test_vector_to_bytes(self, function_id, dependencies, parameters):
"""
Converts test vector into a byte array that can be sent to the target.
:param function_id: Test Function Identifier
:param deps: Dependency list
:param dependencies: Dependency list
:param parameters: Test function input parameters
:return: Byte array and its length
"""
b = bytearray([len(deps)])
if len(deps):
b += bytearray(deps)
b += bytearray([function_id, len(parameters)])
data_bytes = bytearray([len(dependencies)])
if dependencies:
data_bytes += bytearray(dependencies)
data_bytes += bytearray([function_id, len(parameters)])
for typ, param in parameters:
if typ == 'int' or typ == 'exp':
i = int(param)
b += 'I' if typ == 'int' else 'E'
self.align_32bit(b)
b += self.int32_to_bigendian_bytes(i)
data_bytes += 'I' if typ == 'int' else 'E'
self.align_32bit(data_bytes)
data_bytes += self.int32_to_big_endian_bytes(i)
elif typ == 'char*':
param = param.strip('"')
i = len(param) + 1 # + 1 for null termination
b += 'S'
self.align_32bit(b)
b += self.int32_to_bigendian_bytes(i)
b += bytearray(list(param))
b += '\0' # Null terminate
data_bytes += 'S'
self.align_32bit(data_bytes)
data_bytes += self.int32_to_big_endian_bytes(i)
data_bytes += bytearray(list(param))
data_bytes += '\0' # Null terminate
elif typ == 'hex':
hb = self.hex_str_bytes(param)
b += 'H'
self.align_32bit(b)
i = len(hb)
b += self.int32_to_bigendian_bytes(i)
b += hb
length = self.int32_to_bigendian_bytes(len(b))
return b, length
binary_data = self.hex_str_bytes(param)
data_bytes += 'H'
self.align_32bit(data_bytes)
i = len(binary_data)
data_bytes += self.int32_to_big_endian_bytes(i)
data_bytes += binary_data
length = self.int32_to_big_endian_bytes(len(data_bytes))
return data_bytes, length
def run_next_test(self):
"""
@ -289,25 +297,26 @@ class MbedTlsTest(BaseHostTest):
self.test_index += 1
self.dep_index = 0
if self.test_index < len(self.tests):
name, function_id, deps, args = self.tests[self.test_index]
self.run_test(name, function_id, deps, args)
name, function_id, dependencies, args = self.tests[self.test_index]
self.run_test(name, function_id, dependencies, args)
else:
self.notify_complete(True)
def run_test(self, name, function_id, deps, args):
def run_test(self, name, function_id, dependencies, args):
"""
Execute the test on target by sending next test information.
:param name: Test name
:param function_id: function identifier
:param deps: Dependencies list
:param dependencies: Dependencies list
:param args: test parameters
:return:
"""
self.log("Running: %s" % name)
bytes, length = self.test_vector_to_bytes(function_id, deps, args)
self.send_kv(length, bytes)
param_bytes, length = self.test_vector_to_bytes(function_id,
dependencies, args)
self.send_kv(length, param_bytes)
@staticmethod
def get_result(value):
@ -319,52 +328,52 @@ class MbedTlsTest(BaseHostTest):
try:
return int(value)
except ValueError:
ValueError("Result should return error number. Instead received %s" % value)
ValueError("Result should return error number. "
"Instead received %s" % value)
return 0
@event_callback('GO')
def on_go(self, key, value, timestamp):
def on_go(self, _key, _value, _timestamp):
"""
Sent by the target to start first test.
:param key: Event key
:param value: Value. ignored
:param timestamp: Timestamp ignored.
:param _key: Event key
:param _value: Value. ignored
:param _timestamp: Timestamp ignored.
:return:
"""
self.run_next_test()
@event_callback("R")
def on_result(self, key, value, timestamp):
def on_result(self, _key, value, _timestamp):
"""
Handle result. Prints test start, finish required by Greentea
to detect test execution.
:param key: Event key
:param _key: Event key
:param value: Value. ignored
:param timestamp: Timestamp ignored.
:param _timestamp: Timestamp ignored.
:return:
"""
int_val = self.get_result(value)
name, function, deps, args = self.tests[self.test_index]
name, _, _, _ = self.tests[self.test_index]
self.log('{{__testcase_start;%s}}' % name)
self.log('{{__testcase_finish;%s;%d;%d}}' % (name, int_val == 0,
int_val != 0))
self.run_next_test()
@event_callback("F")
def on_failure(self, key, value, timestamp):
def on_failure(self, _key, value, _timestamp):
"""
Handles test execution failure. That means dependency not supported or
Test function not supported. Hence marking test as skipped.
:param key: Event key
:param _key: Event key
:param value: Value. ignored
:param timestamp: Timestamp ignored.
:param _timestamp: Timestamp ignored.
:return:
"""
int_val = self.get_result(value)
name, function, deps, args = self.tests[self.test_index]
if int_val in self.error_str:
err = self.error_str[int_val]
else:

804
tests/scripts/test_generate_test_code.py
View File

File diff suppressed because it is too large Load Diff