mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-11-25 22:45:47 +01:00
a2947ac7bb
As a result, the copyright of contributors other than Arm is now
acknowledged, and the years of publishing are no longer tracked in the
source files.
Also remove the now-redundant lines declaring that the files are part of
MbedTLS.
This commit was generated using the following script:
# ========================
#!/bin/sh
# Find files
find '(' -path './.git' -o -path './3rdparty' ')' -prune -o -type f -print | xargs sed -bi '
# Replace copyright attribution line
s/Copyright.*Arm.*/Copyright The Mbed TLS Contributors/I
# Remove redundant declaration and the preceding line
$!N
/This file is part of Mbed TLS/Id
P
D
'
# ========================
Signed-off-by: Bence Szépkúti <bence.szepkuti@arm.com>
1779 lines
54 KiB
Python
Executable File
1779 lines
54 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Unit test for generate_test_code.py
|
|
#
|
|
# Copyright The Mbed TLS Contributors
|
|
# SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
|
|
#
|
|
# This file is provided under the Apache License 2.0, or the
|
|
# GNU General Public License v2.0 or later.
|
|
#
|
|
# **********
|
|
# Apache License 2.0:
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
# **********
|
|
#
|
|
# **********
|
|
# GNU General Public License v2.0 or later:
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program 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 General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program; if not, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# **********
|
|
|
|
"""
|
|
Unit tests for generate_test_code.py
|
|
"""
|
|
|
|
# pylint: disable=wrong-import-order
|
|
try:
|
|
# Python 2
|
|
from StringIO import StringIO
|
|
except ImportError:
|
|
# Python 3
|
|
from io import StringIO
|
|
from unittest import TestCase, main as unittest_main
|
|
try:
|
|
# Python 2
|
|
from mock import patch
|
|
except ImportError:
|
|
# Python 3
|
|
from unittest.mock import patch
|
|
# pylint: enable=wrong-import-order
|
|
from generate_test_code import gen_dependencies, gen_dependencies_one_line
|
|
from generate_test_code import gen_function_wrapper, gen_dispatch
|
|
from generate_test_code import parse_until_pattern, GeneratorInputError
|
|
from generate_test_code import parse_suite_dependencies
|
|
from generate_test_code import parse_function_dependencies
|
|
from generate_test_code import parse_function_arguments, parse_function_code
|
|
from generate_test_code import parse_functions, END_HEADER_REGEX
|
|
from generate_test_code import END_SUITE_HELPERS_REGEX, escaped_split
|
|
from generate_test_code import parse_test_data, gen_dep_check
|
|
from generate_test_code import gen_expression_check, write_dependencies
|
|
from generate_test_code import write_parameters, gen_suite_dep_checks
|
|
from generate_test_code import gen_from_test_data
|
|
|
|
|
|
class GenDep(TestCase):
|
|
"""
|
|
Test suite for function gen_dep()
|
|
"""
|
|
|
|
def test_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = ['DEP1', 'DEP2']
|
|
dep_start, dep_end = gen_dependencies(dependencies)
|
|
preprocessor1, preprocessor2 = dep_start.splitlines()
|
|
endif1, endif2 = dep_end.splitlines()
|
|
self.assertEqual(preprocessor1, '#if defined(DEP1)',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(preprocessor2, '#if defined(DEP2)',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(endif1, '#endif /* DEP2 */',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(endif2, '#endif /* DEP1 */',
|
|
'Preprocessor generated incorrectly')
|
|
|
|
def test_disabled_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = ['!DEP1', '!DEP2']
|
|
dep_start, dep_end = gen_dependencies(dependencies)
|
|
preprocessor1, preprocessor2 = dep_start.splitlines()
|
|
endif1, endif2 = dep_end.splitlines()
|
|
self.assertEqual(preprocessor1, '#if !defined(DEP1)',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(preprocessor2, '#if !defined(DEP2)',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(endif1, '#endif /* !DEP2 */',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(endif2, '#endif /* !DEP1 */',
|
|
'Preprocessor generated incorrectly')
|
|
|
|
def test_mixed_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = ['!DEP1', 'DEP2']
|
|
dep_start, dep_end = gen_dependencies(dependencies)
|
|
preprocessor1, preprocessor2 = dep_start.splitlines()
|
|
endif1, endif2 = dep_end.splitlines()
|
|
self.assertEqual(preprocessor1, '#if !defined(DEP1)',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(preprocessor2, '#if defined(DEP2)',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(endif1, '#endif /* DEP2 */',
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(endif2, '#endif /* !DEP1 */',
|
|
'Preprocessor generated incorrectly')
|
|
|
|
def test_empty_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = []
|
|
dep_start, dep_end = gen_dependencies(dependencies)
|
|
self.assertEqual(dep_start, '', 'Preprocessor generated incorrectly')
|
|
self.assertEqual(dep_end, '', 'Preprocessor generated incorrectly')
|
|
|
|
def test_large_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = []
|
|
count = 10
|
|
for i in range(count):
|
|
dependencies.append('DEP%d' % i)
|
|
dep_start, dep_end = gen_dependencies(dependencies)
|
|
self.assertEqual(len(dep_start.splitlines()), count,
|
|
'Preprocessor generated incorrectly')
|
|
self.assertEqual(len(dep_end.splitlines()), count,
|
|
'Preprocessor generated incorrectly')
|
|
|
|
|
|
class GenDepOneLine(TestCase):
|
|
"""
|
|
Test Suite for testing gen_dependencies_one_line()
|
|
"""
|
|
|
|
def test_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = ['DEP1', 'DEP2']
|
|
dep_str = gen_dependencies_one_line(dependencies)
|
|
self.assertEqual(dep_str, '#if defined(DEP1) && defined(DEP2)',
|
|
'Preprocessor generated incorrectly')
|
|
|
|
def test_disabled_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = ['!DEP1', '!DEP2']
|
|
dep_str = gen_dependencies_one_line(dependencies)
|
|
self.assertEqual(dep_str, '#if !defined(DEP1) && !defined(DEP2)',
|
|
'Preprocessor generated incorrectly')
|
|
|
|
def test_mixed_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = ['!DEP1', 'DEP2']
|
|
dep_str = gen_dependencies_one_line(dependencies)
|
|
self.assertEqual(dep_str, '#if !defined(DEP1) && defined(DEP2)',
|
|
'Preprocessor generated incorrectly')
|
|
|
|
def test_empty_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = []
|
|
dep_str = gen_dependencies_one_line(dependencies)
|
|
self.assertEqual(dep_str, '', 'Preprocessor generated incorrectly')
|
|
|
|
def test_large_dependencies_list(self):
|
|
"""
|
|
Test that gen_dep() correctly creates dependencies for given
|
|
dependency list.
|
|
:return:
|
|
"""
|
|
dependencies = []
|
|
count = 10
|
|
for i in range(count):
|
|
dependencies.append('DEP%d' % i)
|
|
dep_str = gen_dependencies_one_line(dependencies)
|
|
expected = '#if ' + ' && '.join(['defined(%s)' %
|
|
x for x in dependencies])
|
|
self.assertEqual(dep_str, expected,
|
|
'Preprocessor generated incorrectly')
|
|
|
|
|
|
class GenFunctionWrapper(TestCase):
|
|
"""
|
|
Test Suite for testing gen_function_wrapper()
|
|
"""
|
|
|
|
def test_params_unpack(self):
|
|
"""
|
|
Test that params are properly unpacked in the function call.
|
|
|
|
:return:
|
|
"""
|
|
code = gen_function_wrapper('test_a', '', ('a', 'b', 'c', 'd'))
|
|
expected = '''
|
|
void test_a_wrapper( void ** params )
|
|
{
|
|
|
|
test_a( a, b, c, d );
|
|
}
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
|
|
def test_local(self):
|
|
"""
|
|
Test that params are properly unpacked in the function call.
|
|
|
|
:return:
|
|
"""
|
|
code = gen_function_wrapper('test_a',
|
|
'int x = 1;', ('x', 'b', 'c', 'd'))
|
|
expected = '''
|
|
void test_a_wrapper( void ** params )
|
|
{
|
|
int x = 1;
|
|
test_a( x, b, c, d );
|
|
}
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
|
|
def test_empty_params(self):
|
|
"""
|
|
Test that params are properly unpacked in the function call.
|
|
|
|
:return:
|
|
"""
|
|
code = gen_function_wrapper('test_a', '', ())
|
|
expected = '''
|
|
void test_a_wrapper( void ** params )
|
|
{
|
|
(void)params;
|
|
|
|
test_a( );
|
|
}
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
|
|
|
|
class GenDispatch(TestCase):
|
|
"""
|
|
Test suite for testing gen_dispatch()
|
|
"""
|
|
|
|
def test_dispatch(self):
|
|
"""
|
|
Test that dispatch table entry is generated correctly.
|
|
:return:
|
|
"""
|
|
code = gen_dispatch('test_a', ['DEP1', 'DEP2'])
|
|
expected = '''
|
|
#if defined(DEP1) && defined(DEP2)
|
|
test_a_wrapper,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
|
|
def test_empty_dependencies(self):
|
|
"""
|
|
Test empty dependency list.
|
|
:return:
|
|
"""
|
|
code = gen_dispatch('test_a', [])
|
|
expected = '''
|
|
test_a_wrapper,
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
|
|
|
|
class StringIOWrapper(StringIO):
|
|
"""
|
|
file like class to mock file object in tests.
|
|
"""
|
|
def __init__(self, file_name, data, line_no=0):
|
|
"""
|
|
Init file handle.
|
|
|
|
:param file_name:
|
|
:param data:
|
|
:param line_no:
|
|
"""
|
|
super(StringIOWrapper, self).__init__(data)
|
|
self.line_no = line_no
|
|
self.name = file_name
|
|
|
|
def next(self):
|
|
"""
|
|
Iterator method. This method overrides base class's
|
|
next method and extends the next method to count the line
|
|
numbers as each line is read.
|
|
|
|
:return: Line read from file.
|
|
"""
|
|
parent = super(StringIOWrapper, self)
|
|
if getattr(parent, 'next', None):
|
|
# Python 2
|
|
line = parent.next()
|
|
else:
|
|
# Python 3
|
|
line = parent.__next__()
|
|
return line
|
|
|
|
# Python 3
|
|
__next__ = next
|
|
|
|
def readline(self, length=0):
|
|
"""
|
|
Wrap the base class readline.
|
|
|
|
:param length:
|
|
:return:
|
|
"""
|
|
# pylint: disable=unused-argument
|
|
line = super(StringIOWrapper, self).readline()
|
|
if line is not None:
|
|
self.line_no += 1
|
|
return line
|
|
|
|
|
|
class ParseUntilPattern(TestCase):
|
|
"""
|
|
Test Suite for testing parse_until_pattern().
|
|
"""
|
|
|
|
def test_suite_headers(self):
|
|
"""
|
|
Test that suite headers are parsed correctly.
|
|
|
|
:return:
|
|
"""
|
|
data = '''#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
/* END_HEADER */
|
|
'''
|
|
expected = '''#line 1 "test_suite_ut.function"
|
|
#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data, line_no=0)
|
|
headers = parse_until_pattern(stream, END_HEADER_REGEX)
|
|
self.assertEqual(headers, expected)
|
|
|
|
def test_line_no(self):
|
|
"""
|
|
Test that #line is set to correct line no. in source .function file.
|
|
|
|
:return:
|
|
"""
|
|
data = '''#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
/* END_HEADER */
|
|
'''
|
|
offset_line_no = 5
|
|
expected = '''#line %d "test_suite_ut.function"
|
|
#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
''' % (offset_line_no + 1)
|
|
stream = StringIOWrapper('test_suite_ut.function', data,
|
|
offset_line_no)
|
|
headers = parse_until_pattern(stream, END_HEADER_REGEX)
|
|
self.assertEqual(headers, expected)
|
|
|
|
def test_no_end_header_comment(self):
|
|
"""
|
|
Test that InvalidFileFormat is raised when end header comment is
|
|
missing.
|
|
:return:
|
|
"""
|
|
data = '''#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(GeneratorInputError, parse_until_pattern, stream,
|
|
END_HEADER_REGEX)
|
|
|
|
|
|
class ParseSuiteDependencies(TestCase):
|
|
"""
|
|
Test Suite for testing parse_suite_dependencies().
|
|
"""
|
|
|
|
def test_suite_dependencies(self):
|
|
"""
|
|
|
|
:return:
|
|
"""
|
|
data = '''
|
|
* depends_on:MBEDTLS_ECP_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
'''
|
|
expected = ['MBEDTLS_ECP_C']
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
dependencies = parse_suite_dependencies(stream)
|
|
self.assertEqual(dependencies, expected)
|
|
|
|
def test_no_end_dep_comment(self):
|
|
"""
|
|
Test that InvalidFileFormat is raised when end dep comment is missing.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
* depends_on:MBEDTLS_ECP_C
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(GeneratorInputError, parse_suite_dependencies,
|
|
stream)
|
|
|
|
def test_dependencies_split(self):
|
|
"""
|
|
Test that InvalidFileFormat is raised when end dep comment is missing.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
* depends_on:MBEDTLS_ECP_C:A:B: C : D :F : G: !H
|
|
* END_DEPENDENCIES
|
|
*/
|
|
'''
|
|
expected = ['MBEDTLS_ECP_C', 'A', 'B', 'C', 'D', 'F', 'G', '!H']
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
dependencies = parse_suite_dependencies(stream)
|
|
self.assertEqual(dependencies, expected)
|
|
|
|
|
|
class ParseFuncDependencies(TestCase):
|
|
"""
|
|
Test Suite for testing parse_function_dependencies()
|
|
"""
|
|
|
|
def test_function_dependencies(self):
|
|
"""
|
|
Test that parse_function_dependencies() correctly parses function
|
|
dependencies.
|
|
:return:
|
|
"""
|
|
line = '/* BEGIN_CASE ' \
|
|
'depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */'
|
|
expected = ['MBEDTLS_ENTROPY_NV_SEED', 'MBEDTLS_FS_IO']
|
|
dependencies = parse_function_dependencies(line)
|
|
self.assertEqual(dependencies, expected)
|
|
|
|
def test_no_dependencies(self):
|
|
"""
|
|
Test that parse_function_dependencies() correctly parses function
|
|
dependencies.
|
|
:return:
|
|
"""
|
|
line = '/* BEGIN_CASE */'
|
|
dependencies = parse_function_dependencies(line)
|
|
self.assertEqual(dependencies, [])
|
|
|
|
def test_tolerance(self):
|
|
"""
|
|
Test that parse_function_dependencies() correctly parses function
|
|
dependencies.
|
|
:return:
|
|
"""
|
|
line = '/* BEGIN_CASE depends_on:MBEDTLS_FS_IO: A : !B:C : F*/'
|
|
dependencies = parse_function_dependencies(line)
|
|
self.assertEqual(dependencies, ['MBEDTLS_FS_IO', 'A', '!B', 'C', 'F'])
|
|
|
|
|
|
class ParseFuncSignature(TestCase):
|
|
"""
|
|
Test Suite for parse_function_arguments().
|
|
"""
|
|
|
|
def test_int_and_char_params(self):
|
|
"""
|
|
Test int and char parameters parsing
|
|
:return:
|
|
"""
|
|
line = 'void entropy_threshold( char * a, int b, int result )'
|
|
args, local, arg_dispatch = parse_function_arguments(line)
|
|
self.assertEqual(args, ['char*', 'int', 'int'])
|
|
self.assertEqual(local, '')
|
|
self.assertEqual(arg_dispatch, ['(char *) params[0]',
|
|
'*( (int *) params[1] )',
|
|
'*( (int *) params[2] )'])
|
|
|
|
def test_hex_params(self):
|
|
"""
|
|
Test hex parameters parsing
|
|
:return:
|
|
"""
|
|
line = 'void entropy_threshold( char * a, data_t * h, int result )'
|
|
args, local, arg_dispatch = parse_function_arguments(line)
|
|
self.assertEqual(args, ['char*', 'hex', 'int'])
|
|
self.assertEqual(local,
|
|
' data_t data1 = {(uint8_t *) params[1], '
|
|
'*( (uint32_t *) params[2] )};\n')
|
|
self.assertEqual(arg_dispatch, ['(char *) params[0]',
|
|
'&data1',
|
|
'*( (int *) params[3] )'])
|
|
|
|
def test_unsupported_arg(self):
|
|
"""
|
|
Test unsupported arguments (not among int, char * and data_t)
|
|
:return:
|
|
"""
|
|
line = 'void entropy_threshold( char * a, data_t * h, char result )'
|
|
self.assertRaises(ValueError, parse_function_arguments, line)
|
|
|
|
def test_no_params(self):
|
|
"""
|
|
Test no parameters.
|
|
:return:
|
|
"""
|
|
line = 'void entropy_threshold()'
|
|
args, local, arg_dispatch = parse_function_arguments(line)
|
|
self.assertEqual(args, [])
|
|
self.assertEqual(local, '')
|
|
self.assertEqual(arg_dispatch, [])
|
|
|
|
|
|
class ParseFunctionCode(TestCase):
|
|
"""
|
|
Test suite for testing parse_function_code()
|
|
"""
|
|
|
|
def assert_raises_regex(self, exp, regex, func, *args):
|
|
"""
|
|
Python 2 & 3 portable wrapper of assertRaisesRegex(p)? function.
|
|
|
|
:param exp: Exception type expected to be raised by cb.
|
|
:param regex: Expected exception message
|
|
:param func: callable object under test
|
|
:param args: variable positional arguments
|
|
"""
|
|
parent = super(ParseFunctionCode, self)
|
|
|
|
# Pylint does not appreciate that the super method called
|
|
# conditionally can be available in other Python version
|
|
# then that of Pylint.
|
|
# Workaround is to call the method via getattr.
|
|
# Pylint ignores that the method got via getattr is
|
|
# conditionally executed. Method has to be a callable.
|
|
# Hence, using a dummy callable for getattr default.
|
|
dummy = lambda *x: None
|
|
# First Python 3 assertRaisesRegex is checked, since Python 2
|
|
# assertRaisesRegexp is also available in Python 3 but is
|
|
# marked deprecated.
|
|
for name in ('assertRaisesRegex', 'assertRaisesRegexp'):
|
|
method = getattr(parent, name, dummy)
|
|
if method is not dummy:
|
|
method(exp, regex, func, *args)
|
|
break
|
|
else:
|
|
raise AttributeError(" 'ParseFunctionCode' object has no attribute"
|
|
" 'assertRaisesRegex' or 'assertRaisesRegexp'"
|
|
)
|
|
|
|
def test_no_function(self):
|
|
"""
|
|
Test no test function found.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
No
|
|
test
|
|
function
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
err_msg = 'file: test_suite_ut.function - Test functions not found!'
|
|
self.assert_raises_regex(GeneratorInputError, err_msg,
|
|
parse_function_code, stream, [], [])
|
|
|
|
def test_no_end_case_comment(self):
|
|
"""
|
|
Test missing end case.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
void test_func()
|
|
{
|
|
}
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
err_msg = r'file: test_suite_ut.function - '\
|
|
'end case pattern .*? not found!'
|
|
self.assert_raises_regex(GeneratorInputError, err_msg,
|
|
parse_function_code, stream, [], [])
|
|
|
|
@patch("generate_test_code.parse_function_arguments")
|
|
def test_function_called(self,
|
|
parse_function_arguments_mock):
|
|
"""
|
|
Test parse_function_code()
|
|
:return:
|
|
"""
|
|
parse_function_arguments_mock.return_value = ([], '', [])
|
|
data = '''
|
|
void test_func()
|
|
{
|
|
}
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(GeneratorInputError, parse_function_code,
|
|
stream, [], [])
|
|
self.assertTrue(parse_function_arguments_mock.called)
|
|
parse_function_arguments_mock.assert_called_with('void test_func()\n')
|
|
|
|
@patch("generate_test_code.gen_dispatch")
|
|
@patch("generate_test_code.gen_dependencies")
|
|
@patch("generate_test_code.gen_function_wrapper")
|
|
@patch("generate_test_code.parse_function_arguments")
|
|
def test_return(self, parse_function_arguments_mock,
|
|
gen_function_wrapper_mock,
|
|
gen_dependencies_mock,
|
|
gen_dispatch_mock):
|
|
"""
|
|
Test generated code.
|
|
:return:
|
|
"""
|
|
parse_function_arguments_mock.return_value = ([], '', [])
|
|
gen_function_wrapper_mock.return_value = ''
|
|
gen_dependencies_mock.side_effect = gen_dependencies
|
|
gen_dispatch_mock.side_effect = gen_dispatch
|
|
data = '''
|
|
void func()
|
|
{
|
|
ba ba black sheep
|
|
have you any wool
|
|
}
|
|
/* END_CASE */
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
name, arg, code, dispatch_code = parse_function_code(stream, [], [])
|
|
|
|
self.assertTrue(parse_function_arguments_mock.called)
|
|
parse_function_arguments_mock.assert_called_with('void func()\n')
|
|
gen_function_wrapper_mock.assert_called_with('test_func', '', [])
|
|
self.assertEqual(name, 'test_func')
|
|
self.assertEqual(arg, [])
|
|
expected = '''#line 1 "test_suite_ut.function"
|
|
|
|
void test_func()
|
|
{
|
|
ba ba black sheep
|
|
have you any wool
|
|
exit:
|
|
;
|
|
}
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
self.assertEqual(dispatch_code, "\n test_func_wrapper,\n")
|
|
|
|
@patch("generate_test_code.gen_dispatch")
|
|
@patch("generate_test_code.gen_dependencies")
|
|
@patch("generate_test_code.gen_function_wrapper")
|
|
@patch("generate_test_code.parse_function_arguments")
|
|
def test_with_exit_label(self, parse_function_arguments_mock,
|
|
gen_function_wrapper_mock,
|
|
gen_dependencies_mock,
|
|
gen_dispatch_mock):
|
|
"""
|
|
Test when exit label is present.
|
|
:return:
|
|
"""
|
|
parse_function_arguments_mock.return_value = ([], '', [])
|
|
gen_function_wrapper_mock.return_value = ''
|
|
gen_dependencies_mock.side_effect = gen_dependencies
|
|
gen_dispatch_mock.side_effect = gen_dispatch
|
|
data = '''
|
|
void func()
|
|
{
|
|
ba ba black sheep
|
|
have you any wool
|
|
exit:
|
|
yes sir yes sir
|
|
3 bags full
|
|
}
|
|
/* END_CASE */
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
_, _, code, _ = parse_function_code(stream, [], [])
|
|
|
|
expected = '''#line 1 "test_suite_ut.function"
|
|
|
|
void test_func()
|
|
{
|
|
ba ba black sheep
|
|
have you any wool
|
|
exit:
|
|
yes sir yes sir
|
|
3 bags full
|
|
}
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
|
|
def test_non_void_function(self):
|
|
"""
|
|
Test invalid signature (non void).
|
|
:return:
|
|
"""
|
|
data = 'int entropy_threshold( char * a, data_t * h, int result )'
|
|
err_msg = 'file: test_suite_ut.function - Test functions not found!'
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assert_raises_regex(GeneratorInputError, err_msg,
|
|
parse_function_code, stream, [], [])
|
|
|
|
@patch("generate_test_code.gen_dispatch")
|
|
@patch("generate_test_code.gen_dependencies")
|
|
@patch("generate_test_code.gen_function_wrapper")
|
|
@patch("generate_test_code.parse_function_arguments")
|
|
def test_functio_name_on_newline(self, parse_function_arguments_mock,
|
|
gen_function_wrapper_mock,
|
|
gen_dependencies_mock,
|
|
gen_dispatch_mock):
|
|
"""
|
|
Test when exit label is present.
|
|
:return:
|
|
"""
|
|
parse_function_arguments_mock.return_value = ([], '', [])
|
|
gen_function_wrapper_mock.return_value = ''
|
|
gen_dependencies_mock.side_effect = gen_dependencies
|
|
gen_dispatch_mock.side_effect = gen_dispatch
|
|
data = '''
|
|
void
|
|
|
|
|
|
func()
|
|
{
|
|
ba ba black sheep
|
|
have you any wool
|
|
exit:
|
|
yes sir yes sir
|
|
3 bags full
|
|
}
|
|
/* END_CASE */
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
_, _, code, _ = parse_function_code(stream, [], [])
|
|
|
|
expected = '''#line 1 "test_suite_ut.function"
|
|
|
|
void
|
|
|
|
|
|
test_func()
|
|
{
|
|
ba ba black sheep
|
|
have you any wool
|
|
exit:
|
|
yes sir yes sir
|
|
3 bags full
|
|
}
|
|
'''
|
|
self.assertEqual(code, expected)
|
|
|
|
|
|
class ParseFunction(TestCase):
|
|
"""
|
|
Test Suite for testing parse_functions()
|
|
"""
|
|
|
|
@patch("generate_test_code.parse_until_pattern")
|
|
def test_begin_header(self, parse_until_pattern_mock):
|
|
"""
|
|
Test that begin header is checked and parse_until_pattern() is called.
|
|
:return:
|
|
"""
|
|
def stop(*_unused):
|
|
"""Stop when parse_until_pattern is called."""
|
|
raise Exception
|
|
parse_until_pattern_mock.side_effect = stop
|
|
data = '''/* BEGIN_HEADER */
|
|
#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
/* END_HEADER */
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(Exception, parse_functions, stream)
|
|
parse_until_pattern_mock.assert_called_with(stream, END_HEADER_REGEX)
|
|
self.assertEqual(stream.line_no, 1)
|
|
|
|
@patch("generate_test_code.parse_until_pattern")
|
|
def test_begin_helper(self, parse_until_pattern_mock):
|
|
"""
|
|
Test that begin helper is checked and parse_until_pattern() is called.
|
|
:return:
|
|
"""
|
|
def stop(*_unused):
|
|
"""Stop when parse_until_pattern is called."""
|
|
raise Exception
|
|
parse_until_pattern_mock.side_effect = stop
|
|
data = '''/* BEGIN_SUITE_HELPERS */
|
|
void print_hello_world()
|
|
{
|
|
printf("Hello World!\n");
|
|
}
|
|
/* END_SUITE_HELPERS */
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(Exception, parse_functions, stream)
|
|
parse_until_pattern_mock.assert_called_with(stream,
|
|
END_SUITE_HELPERS_REGEX)
|
|
self.assertEqual(stream.line_no, 1)
|
|
|
|
@patch("generate_test_code.parse_suite_dependencies")
|
|
def test_begin_dep(self, parse_suite_dependencies_mock):
|
|
"""
|
|
Test that begin dep is checked and parse_suite_dependencies() is
|
|
called.
|
|
:return:
|
|
"""
|
|
def stop(*_unused):
|
|
"""Stop when parse_until_pattern is called."""
|
|
raise Exception
|
|
parse_suite_dependencies_mock.side_effect = stop
|
|
data = '''/* BEGIN_DEPENDENCIES
|
|
* depends_on:MBEDTLS_ECP_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(Exception, parse_functions, stream)
|
|
parse_suite_dependencies_mock.assert_called_with(stream)
|
|
self.assertEqual(stream.line_no, 1)
|
|
|
|
@patch("generate_test_code.parse_function_dependencies")
|
|
def test_begin_function_dep(self, func_mock):
|
|
"""
|
|
Test that begin dep is checked and parse_function_dependencies() is
|
|
called.
|
|
:return:
|
|
"""
|
|
def stop(*_unused):
|
|
"""Stop when parse_until_pattern is called."""
|
|
raise Exception
|
|
func_mock.side_effect = stop
|
|
|
|
dependencies_str = '/* BEGIN_CASE ' \
|
|
'depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */\n'
|
|
data = '''%svoid test_func()
|
|
{
|
|
}
|
|
''' % dependencies_str
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(Exception, parse_functions, stream)
|
|
func_mock.assert_called_with(dependencies_str)
|
|
self.assertEqual(stream.line_no, 1)
|
|
|
|
@patch("generate_test_code.parse_function_code")
|
|
@patch("generate_test_code.parse_function_dependencies")
|
|
def test_return(self, func_mock1, func_mock2):
|
|
"""
|
|
Test that begin case is checked and parse_function_code() is called.
|
|
:return:
|
|
"""
|
|
func_mock1.return_value = []
|
|
in_func_code = '''void test_func()
|
|
{
|
|
}
|
|
'''
|
|
func_dispatch = '''
|
|
test_func_wrapper,
|
|
'''
|
|
func_mock2.return_value = 'test_func', [],\
|
|
in_func_code, func_dispatch
|
|
dependencies_str = '/* BEGIN_CASE ' \
|
|
'depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */\n'
|
|
data = '''%svoid test_func()
|
|
{
|
|
}
|
|
''' % dependencies_str
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
suite_dependencies, dispatch_code, func_code, func_info = \
|
|
parse_functions(stream)
|
|
func_mock1.assert_called_with(dependencies_str)
|
|
func_mock2.assert_called_with(stream, [], [])
|
|
self.assertEqual(stream.line_no, 5)
|
|
self.assertEqual(suite_dependencies, [])
|
|
expected_dispatch_code = '''/* Function Id: 0 */
|
|
|
|
test_func_wrapper,
|
|
'''
|
|
self.assertEqual(dispatch_code, expected_dispatch_code)
|
|
self.assertEqual(func_code, in_func_code)
|
|
self.assertEqual(func_info, {'test_func': (0, [])})
|
|
|
|
def test_parsing(self):
|
|
"""
|
|
Test case parsing.
|
|
:return:
|
|
"""
|
|
data = '''/* BEGIN_HEADER */
|
|
#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
/* END_HEADER */
|
|
|
|
/* BEGIN_DEPENDENCIES
|
|
* depends_on:MBEDTLS_ECP_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
|
|
void func1()
|
|
{
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
|
|
void func2()
|
|
{
|
|
}
|
|
/* END_CASE */
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
suite_dependencies, dispatch_code, func_code, func_info = \
|
|
parse_functions(stream)
|
|
self.assertEqual(stream.line_no, 23)
|
|
self.assertEqual(suite_dependencies, ['MBEDTLS_ECP_C'])
|
|
|
|
expected_dispatch_code = '''/* Function Id: 0 */
|
|
|
|
#if defined(MBEDTLS_ECP_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
|
|
test_func1_wrapper,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
/* Function Id: 1 */
|
|
|
|
#if defined(MBEDTLS_ECP_C) && defined(MBEDTLS_ENTROPY_NV_SEED) && defined(MBEDTLS_FS_IO)
|
|
test_func2_wrapper,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
'''
|
|
self.assertEqual(dispatch_code, expected_dispatch_code)
|
|
expected_func_code = '''#if defined(MBEDTLS_ECP_C)
|
|
#line 2 "test_suite_ut.function"
|
|
#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
#if defined(MBEDTLS_ENTROPY_NV_SEED)
|
|
#if defined(MBEDTLS_FS_IO)
|
|
#line 13 "test_suite_ut.function"
|
|
void test_func1()
|
|
{
|
|
exit:
|
|
;
|
|
}
|
|
|
|
void test_func1_wrapper( void ** params )
|
|
{
|
|
(void)params;
|
|
|
|
test_func1( );
|
|
}
|
|
#endif /* MBEDTLS_FS_IO */
|
|
#endif /* MBEDTLS_ENTROPY_NV_SEED */
|
|
#if defined(MBEDTLS_ENTROPY_NV_SEED)
|
|
#if defined(MBEDTLS_FS_IO)
|
|
#line 19 "test_suite_ut.function"
|
|
void test_func2()
|
|
{
|
|
exit:
|
|
;
|
|
}
|
|
|
|
void test_func2_wrapper( void ** params )
|
|
{
|
|
(void)params;
|
|
|
|
test_func2( );
|
|
}
|
|
#endif /* MBEDTLS_FS_IO */
|
|
#endif /* MBEDTLS_ENTROPY_NV_SEED */
|
|
#endif /* MBEDTLS_ECP_C */
|
|
'''
|
|
self.assertEqual(func_code, expected_func_code)
|
|
self.assertEqual(func_info, {'test_func1': (0, []),
|
|
'test_func2': (1, [])})
|
|
|
|
def test_same_function_name(self):
|
|
"""
|
|
Test name conflict.
|
|
:return:
|
|
"""
|
|
data = '''/* BEGIN_HEADER */
|
|
#include "mbedtls/ecp.h"
|
|
|
|
#define ECP_PF_UNKNOWN -1
|
|
/* END_HEADER */
|
|
|
|
/* BEGIN_DEPENDENCIES
|
|
* depends_on:MBEDTLS_ECP_C
|
|
* END_DEPENDENCIES
|
|
*/
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
|
|
void func()
|
|
{
|
|
}
|
|
/* END_CASE */
|
|
|
|
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
|
|
void func()
|
|
{
|
|
}
|
|
/* END_CASE */
|
|
'''
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
self.assertRaises(GeneratorInputError, parse_functions, stream)
|
|
|
|
|
|
class EscapedSplit(TestCase):
|
|
"""
|
|
Test suite for testing escaped_split().
|
|
Note: Since escaped_split() output is used to write back to the
|
|
intermediate data file. Any escape characters in the input are
|
|
retained in the output.
|
|
"""
|
|
|
|
def test_invalid_input(self):
|
|
"""
|
|
Test when input split character is not a character.
|
|
:return:
|
|
"""
|
|
self.assertRaises(ValueError, escaped_split, '', 'string')
|
|
|
|
def test_empty_string(self):
|
|
"""
|
|
Test empty string input.
|
|
:return:
|
|
"""
|
|
splits = escaped_split('', ':')
|
|
self.assertEqual(splits, [])
|
|
|
|
def test_no_escape(self):
|
|
"""
|
|
Test with no escape character. The behaviour should be same as
|
|
str.split()
|
|
:return:
|
|
"""
|
|
test_str = 'yahoo:google'
|
|
splits = escaped_split(test_str, ':')
|
|
self.assertEqual(splits, test_str.split(':'))
|
|
|
|
def test_escaped_input(self):
|
|
"""
|
|
Test input that has escaped delimiter.
|
|
:return:
|
|
"""
|
|
test_str = r'yahoo\:google:facebook'
|
|
splits = escaped_split(test_str, ':')
|
|
self.assertEqual(splits, [r'yahoo\:google', 'facebook'])
|
|
|
|
def test_escaped_escape(self):
|
|
"""
|
|
Test input that has escaped delimiter.
|
|
:return:
|
|
"""
|
|
test_str = r'yahoo\\:google:facebook'
|
|
splits = escaped_split(test_str, ':')
|
|
self.assertEqual(splits, [r'yahoo\\', 'google', 'facebook'])
|
|
|
|
def test_all_at_once(self):
|
|
"""
|
|
Test input that has escaped delimiter.
|
|
:return:
|
|
"""
|
|
test_str = r'yahoo\\:google:facebook\:instagram\\:bbc\\:wikipedia'
|
|
splits = escaped_split(test_str, ':')
|
|
self.assertEqual(splits, [r'yahoo\\', r'google',
|
|
r'facebook\:instagram\\',
|
|
r'bbc\\', r'wikipedia'])
|
|
|
|
|
|
class ParseTestData(TestCase):
|
|
"""
|
|
Test suite for parse test data.
|
|
"""
|
|
|
|
def test_parser(self):
|
|
"""
|
|
Test that tests are parsed correctly from data file.
|
|
:return:
|
|
"""
|
|
data = """
|
|
Diffie-Hellman full exchange #1
|
|
dhm_do_dhm:10:"23":10:"5"
|
|
|
|
Diffie-Hellman full exchange #2
|
|
dhm_do_dhm:10:"93450983094850938450983409623":10:"9345098304850938450983409622"
|
|
|
|
Diffie-Hellman full exchange #3
|
|
dhm_do_dhm:10:"9345098382739712938719287391879381271":10:"9345098792137312973297123912791271"
|
|
|
|
Diffie-Hellman selftest
|
|
dhm_selftest:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
# List of (name, function_name, dependencies, args)
|
|
tests = list(parse_test_data(stream))
|
|
test1, test2, test3, test4 = tests
|
|
self.assertEqual(test1[0], 'Diffie-Hellman full exchange #1')
|
|
self.assertEqual(test1[1], 'dhm_do_dhm')
|
|
self.assertEqual(test1[2], [])
|
|
self.assertEqual(test1[3], ['10', '"23"', '10', '"5"'])
|
|
|
|
self.assertEqual(test2[0], 'Diffie-Hellman full exchange #2')
|
|
self.assertEqual(test2[1], 'dhm_do_dhm')
|
|
self.assertEqual(test2[2], [])
|
|
self.assertEqual(test2[3], ['10', '"93450983094850938450983409623"',
|
|
'10', '"9345098304850938450983409622"'])
|
|
|
|
self.assertEqual(test3[0], 'Diffie-Hellman full exchange #3')
|
|
self.assertEqual(test3[1], 'dhm_do_dhm')
|
|
self.assertEqual(test3[2], [])
|
|
self.assertEqual(test3[3], ['10',
|
|
'"9345098382739712938719287391879381271"',
|
|
'10',
|
|
'"9345098792137312973297123912791271"'])
|
|
|
|
self.assertEqual(test4[0], 'Diffie-Hellman selftest')
|
|
self.assertEqual(test4[1], 'dhm_selftest')
|
|
self.assertEqual(test4[2], [])
|
|
self.assertEqual(test4[3], [])
|
|
|
|
def test_with_dependencies(self):
|
|
"""
|
|
Test that tests with dependencies are parsed.
|
|
:return:
|
|
"""
|
|
data = """
|
|
Diffie-Hellman full exchange #1
|
|
depends_on:YAHOO
|
|
dhm_do_dhm:10:"23":10:"5"
|
|
|
|
Diffie-Hellman full exchange #2
|
|
dhm_do_dhm:10:"93450983094850938450983409623":10:"9345098304850938450983409622"
|
|
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
# List of (name, function_name, dependencies, args)
|
|
tests = list(parse_test_data(stream))
|
|
test1, test2 = tests
|
|
self.assertEqual(test1[0], 'Diffie-Hellman full exchange #1')
|
|
self.assertEqual(test1[1], 'dhm_do_dhm')
|
|
self.assertEqual(test1[2], ['YAHOO'])
|
|
self.assertEqual(test1[3], ['10', '"23"', '10', '"5"'])
|
|
|
|
self.assertEqual(test2[0], 'Diffie-Hellman full exchange #2')
|
|
self.assertEqual(test2[1], 'dhm_do_dhm')
|
|
self.assertEqual(test2[2], [])
|
|
self.assertEqual(test2[3], ['10', '"93450983094850938450983409623"',
|
|
'10', '"9345098304850938450983409622"'])
|
|
|
|
def test_no_args(self):
|
|
"""
|
|
Test GeneratorInputError is raised when test function name and
|
|
args line is missing.
|
|
:return:
|
|
"""
|
|
data = """
|
|
Diffie-Hellman full exchange #1
|
|
depends_on:YAHOO
|
|
|
|
|
|
Diffie-Hellman full exchange #2
|
|
dhm_do_dhm:10:"93450983094850938450983409623":10:"9345098304850938450983409622"
|
|
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
err = None
|
|
try:
|
|
for _, _, _, _ in parse_test_data(stream):
|
|
pass
|
|
except GeneratorInputError as err:
|
|
self.assertEqual(type(err), GeneratorInputError)
|
|
|
|
def test_incomplete_data(self):
|
|
"""
|
|
Test GeneratorInputError is raised when test function name
|
|
and args line is missing.
|
|
:return:
|
|
"""
|
|
data = """
|
|
Diffie-Hellman full exchange #1
|
|
depends_on:YAHOO
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.function', data)
|
|
err = None
|
|
try:
|
|
for _, _, _, _ in parse_test_data(stream):
|
|
pass
|
|
except GeneratorInputError as err:
|
|
self.assertEqual(type(err), GeneratorInputError)
|
|
|
|
|
|
class GenDepCheck(TestCase):
|
|
"""
|
|
Test suite for gen_dep_check(). It is assumed this function is
|
|
called with valid inputs.
|
|
"""
|
|
|
|
def test_gen_dep_check(self):
|
|
"""
|
|
Test that dependency check code generated correctly.
|
|
:return:
|
|
"""
|
|
expected = """
|
|
case 5:
|
|
{
|
|
#if defined(YAHOO)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;"""
|
|
out = gen_dep_check(5, 'YAHOO')
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_not_defined_dependency(self):
|
|
"""
|
|
Test dependency with !.
|
|
:return:
|
|
"""
|
|
expected = """
|
|
case 5:
|
|
{
|
|
#if !defined(YAHOO)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;"""
|
|
out = gen_dep_check(5, '!YAHOO')
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_empty_dependency(self):
|
|
"""
|
|
Test invalid dependency input.
|
|
:return:
|
|
"""
|
|
self.assertRaises(GeneratorInputError, gen_dep_check, 5, '!')
|
|
|
|
def test_negative_dep_id(self):
|
|
"""
|
|
Test invalid dependency input.
|
|
:return:
|
|
"""
|
|
self.assertRaises(GeneratorInputError, gen_dep_check, -1, 'YAHOO')
|
|
|
|
|
|
class GenExpCheck(TestCase):
|
|
"""
|
|
Test suite for gen_expression_check(). It is assumed this function
|
|
is called with valid inputs.
|
|
"""
|
|
|
|
def test_gen_exp_check(self):
|
|
"""
|
|
Test that expression check code generated correctly.
|
|
:return:
|
|
"""
|
|
expected = """
|
|
case 5:
|
|
{
|
|
*out_value = YAHOO;
|
|
}
|
|
break;"""
|
|
out = gen_expression_check(5, 'YAHOO')
|
|
self.assertEqual(out, expected)
|
|
|
|
def test_invalid_expression(self):
|
|
"""
|
|
Test invalid expression input.
|
|
:return:
|
|
"""
|
|
self.assertRaises(GeneratorInputError, gen_expression_check, 5, '')
|
|
|
|
def test_negative_exp_id(self):
|
|
"""
|
|
Test invalid expression id.
|
|
:return:
|
|
"""
|
|
self.assertRaises(GeneratorInputError, gen_expression_check,
|
|
-1, 'YAHOO')
|
|
|
|
|
|
class WriteDependencies(TestCase):
|
|
"""
|
|
Test suite for testing write_dependencies.
|
|
"""
|
|
|
|
def test_no_test_dependencies(self):
|
|
"""
|
|
Test when test dependencies input is empty.
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_dependencies = []
|
|
dep_check_code = write_dependencies(stream, [], unique_dependencies)
|
|
self.assertEqual(dep_check_code, '')
|
|
self.assertEqual(len(unique_dependencies), 0)
|
|
self.assertEqual(stream.getvalue(), '')
|
|
|
|
def test_unique_dep_ids(self):
|
|
"""
|
|
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_dependencies = []
|
|
dep_check_code = write_dependencies(stream, ['DEP3', 'DEP2', 'DEP1'],
|
|
unique_dependencies)
|
|
expect_dep_check_code = '''
|
|
case 0:
|
|
{
|
|
#if defined(DEP3)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
#if defined(DEP2)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
#if defined(DEP1)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;'''
|
|
self.assertEqual(dep_check_code, expect_dep_check_code)
|
|
self.assertEqual(len(unique_dependencies), 3)
|
|
self.assertEqual(stream.getvalue(), 'depends_on:0:1:2\n')
|
|
|
|
def test_dep_id_repeat(self):
|
|
"""
|
|
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_dependencies = []
|
|
dep_check_code = ''
|
|
dep_check_code += write_dependencies(stream, ['DEP3', 'DEP2'],
|
|
unique_dependencies)
|
|
dep_check_code += write_dependencies(stream, ['DEP2', 'DEP1'],
|
|
unique_dependencies)
|
|
dep_check_code += write_dependencies(stream, ['DEP1', 'DEP3'],
|
|
unique_dependencies)
|
|
expect_dep_check_code = '''
|
|
case 0:
|
|
{
|
|
#if defined(DEP3)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
#if defined(DEP2)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
#if defined(DEP1)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;'''
|
|
self.assertEqual(dep_check_code, expect_dep_check_code)
|
|
self.assertEqual(len(unique_dependencies), 3)
|
|
self.assertEqual(stream.getvalue(),
|
|
'depends_on:0:1\ndepends_on:1:2\ndepends_on:2:0\n')
|
|
|
|
|
|
class WriteParams(TestCase):
|
|
"""
|
|
Test Suite for testing write_parameters().
|
|
"""
|
|
|
|
def test_no_params(self):
|
|
"""
|
|
Test with empty test_args
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_expressions = []
|
|
expression_code = write_parameters(stream, [], [], unique_expressions)
|
|
self.assertEqual(len(unique_expressions), 0)
|
|
self.assertEqual(expression_code, '')
|
|
self.assertEqual(stream.getvalue(), '\n')
|
|
|
|
def test_no_exp_param(self):
|
|
"""
|
|
Test when there is no macro or expression in the params.
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_expressions = []
|
|
expression_code = write_parameters(stream, ['"Yahoo"', '"abcdef00"',
|
|
'0'],
|
|
['char*', 'hex', 'int'],
|
|
unique_expressions)
|
|
self.assertEqual(len(unique_expressions), 0)
|
|
self.assertEqual(expression_code, '')
|
|
self.assertEqual(stream.getvalue(),
|
|
':char*:"Yahoo":hex:"abcdef00":int:0\n')
|
|
|
|
def test_hex_format_int_param(self):
|
|
"""
|
|
Test int parameter in hex format.
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_expressions = []
|
|
expression_code = write_parameters(stream,
|
|
['"Yahoo"', '"abcdef00"', '0xAA'],
|
|
['char*', 'hex', 'int'],
|
|
unique_expressions)
|
|
self.assertEqual(len(unique_expressions), 0)
|
|
self.assertEqual(expression_code, '')
|
|
self.assertEqual(stream.getvalue(),
|
|
':char*:"Yahoo":hex:"abcdef00":int:0xAA\n')
|
|
|
|
def test_with_exp_param(self):
|
|
"""
|
|
Test when there is macro or expression in the params.
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_expressions = []
|
|
expression_code = write_parameters(stream,
|
|
['"Yahoo"', '"abcdef00"', '0',
|
|
'MACRO1', 'MACRO2', 'MACRO3'],
|
|
['char*', 'hex', 'int',
|
|
'int', 'int', 'int'],
|
|
unique_expressions)
|
|
self.assertEqual(len(unique_expressions), 3)
|
|
self.assertEqual(unique_expressions, ['MACRO1', 'MACRO2', 'MACRO3'])
|
|
expected_expression_code = '''
|
|
case 0:
|
|
{
|
|
*out_value = MACRO1;
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
*out_value = MACRO2;
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
*out_value = MACRO3;
|
|
}
|
|
break;'''
|
|
self.assertEqual(expression_code, expected_expression_code)
|
|
self.assertEqual(stream.getvalue(),
|
|
':char*:"Yahoo":hex:"abcdef00":int:0:exp:0:exp:1'
|
|
':exp:2\n')
|
|
|
|
def test_with_repeat_calls(self):
|
|
"""
|
|
Test when write_parameter() is called with same macro or expression.
|
|
:return:
|
|
"""
|
|
stream = StringIOWrapper('test_suite_ut.data', '')
|
|
unique_expressions = []
|
|
expression_code = ''
|
|
expression_code += write_parameters(stream,
|
|
['"Yahoo"', 'MACRO1', 'MACRO2'],
|
|
['char*', 'int', 'int'],
|
|
unique_expressions)
|
|
expression_code += write_parameters(stream,
|
|
['"abcdef00"', 'MACRO2', 'MACRO3'],
|
|
['hex', 'int', 'int'],
|
|
unique_expressions)
|
|
expression_code += write_parameters(stream,
|
|
['0', 'MACRO3', 'MACRO1'],
|
|
['int', 'int', 'int'],
|
|
unique_expressions)
|
|
self.assertEqual(len(unique_expressions), 3)
|
|
self.assertEqual(unique_expressions, ['MACRO1', 'MACRO2', 'MACRO3'])
|
|
expected_expression_code = '''
|
|
case 0:
|
|
{
|
|
*out_value = MACRO1;
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
*out_value = MACRO2;
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
*out_value = MACRO3;
|
|
}
|
|
break;'''
|
|
self.assertEqual(expression_code, expected_expression_code)
|
|
expected_data_file = ''':char*:"Yahoo":exp:0:exp:1
|
|
:hex:"abcdef00":exp:1:exp:2
|
|
:int:0:exp:2:exp:0
|
|
'''
|
|
self.assertEqual(stream.getvalue(), expected_data_file)
|
|
|
|
|
|
class GenTestSuiteDependenciesChecks(TestCase):
|
|
"""
|
|
Test suite for testing gen_suite_dep_checks()
|
|
"""
|
|
def test_empty_suite_dependencies(self):
|
|
"""
|
|
Test with empty suite_dependencies list.
|
|
|
|
:return:
|
|
"""
|
|
dep_check_code, expression_code = \
|
|
gen_suite_dep_checks([], 'DEP_CHECK_CODE', 'EXPRESSION_CODE')
|
|
self.assertEqual(dep_check_code, 'DEP_CHECK_CODE')
|
|
self.assertEqual(expression_code, 'EXPRESSION_CODE')
|
|
|
|
def test_suite_dependencies(self):
|
|
"""
|
|
Test with suite_dependencies list.
|
|
|
|
:return:
|
|
"""
|
|
dep_check_code, expression_code = \
|
|
gen_suite_dep_checks(['SUITE_DEP'], 'DEP_CHECK_CODE',
|
|
'EXPRESSION_CODE')
|
|
expected_dep_check_code = '''
|
|
#if defined(SUITE_DEP)
|
|
DEP_CHECK_CODE
|
|
#endif
|
|
'''
|
|
expected_expression_code = '''
|
|
#if defined(SUITE_DEP)
|
|
EXPRESSION_CODE
|
|
#endif
|
|
'''
|
|
self.assertEqual(dep_check_code, expected_dep_check_code)
|
|
self.assertEqual(expression_code, expected_expression_code)
|
|
|
|
def test_no_dep_no_exp(self):
|
|
"""
|
|
Test when there are no dependency and expression code.
|
|
:return:
|
|
"""
|
|
dep_check_code, expression_code = gen_suite_dep_checks([], '', '')
|
|
self.assertEqual(dep_check_code, '')
|
|
self.assertEqual(expression_code, '')
|
|
|
|
|
|
class GenFromTestData(TestCase):
|
|
"""
|
|
Test suite for gen_from_test_data()
|
|
"""
|
|
|
|
@staticmethod
|
|
@patch("generate_test_code.write_dependencies")
|
|
@patch("generate_test_code.write_parameters")
|
|
@patch("generate_test_code.gen_suite_dep_checks")
|
|
def test_intermediate_data_file(func_mock1,
|
|
write_parameters_mock,
|
|
write_dependencies_mock):
|
|
"""
|
|
Test that intermediate data file is written with expected data.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
My test
|
|
depends_on:DEP1
|
|
func1:0
|
|
'''
|
|
data_f = StringIOWrapper('test_suite_ut.data', data)
|
|
out_data_f = StringIOWrapper('test_suite_ut.datax', '')
|
|
func_info = {'test_func1': (1, ('int',))}
|
|
suite_dependencies = []
|
|
write_parameters_mock.side_effect = write_parameters
|
|
write_dependencies_mock.side_effect = write_dependencies
|
|
func_mock1.side_effect = gen_suite_dep_checks
|
|
gen_from_test_data(data_f, out_data_f, func_info, suite_dependencies)
|
|
write_dependencies_mock.assert_called_with(out_data_f,
|
|
['DEP1'], ['DEP1'])
|
|
write_parameters_mock.assert_called_with(out_data_f, ['0'],
|
|
('int',), [])
|
|
expected_dep_check_code = '''
|
|
case 0:
|
|
{
|
|
#if defined(DEP1)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;'''
|
|
func_mock1.assert_called_with(
|
|
suite_dependencies, expected_dep_check_code, '')
|
|
|
|
def test_function_not_found(self):
|
|
"""
|
|
Test that AssertError is raised when function info in not found.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
My test
|
|
depends_on:DEP1
|
|
func1:0
|
|
'''
|
|
data_f = StringIOWrapper('test_suite_ut.data', data)
|
|
out_data_f = StringIOWrapper('test_suite_ut.datax', '')
|
|
func_info = {'test_func2': (1, ('int',))}
|
|
suite_dependencies = []
|
|
self.assertRaises(GeneratorInputError, gen_from_test_data,
|
|
data_f, out_data_f, func_info, suite_dependencies)
|
|
|
|
def test_different_func_args(self):
|
|
"""
|
|
Test that AssertError is raised when no. of parameters and
|
|
function args differ.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
My test
|
|
depends_on:DEP1
|
|
func1:0
|
|
'''
|
|
data_f = StringIOWrapper('test_suite_ut.data', data)
|
|
out_data_f = StringIOWrapper('test_suite_ut.datax', '')
|
|
func_info = {'test_func2': (1, ('int', 'hex'))}
|
|
suite_dependencies = []
|
|
self.assertRaises(GeneratorInputError, gen_from_test_data, data_f,
|
|
out_data_f, func_info, suite_dependencies)
|
|
|
|
def test_output(self):
|
|
"""
|
|
Test that intermediate data file is written with expected data.
|
|
:return:
|
|
"""
|
|
data = '''
|
|
My test 1
|
|
depends_on:DEP1
|
|
func1:0:0xfa:MACRO1:MACRO2
|
|
|
|
My test 2
|
|
depends_on:DEP1:DEP2
|
|
func2:"yahoo":88:MACRO1
|
|
'''
|
|
data_f = StringIOWrapper('test_suite_ut.data', data)
|
|
out_data_f = StringIOWrapper('test_suite_ut.datax', '')
|
|
func_info = {'test_func1': (0, ('int', 'int', 'int', 'int')),
|
|
'test_func2': (1, ('char*', 'int', 'int'))}
|
|
suite_dependencies = []
|
|
dep_check_code, expression_code = \
|
|
gen_from_test_data(data_f, out_data_f, func_info,
|
|
suite_dependencies)
|
|
expected_dep_check_code = '''
|
|
case 0:
|
|
{
|
|
#if defined(DEP1)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
#if defined(DEP2)
|
|
ret = DEPENDENCY_SUPPORTED;
|
|
#else
|
|
ret = DEPENDENCY_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
break;'''
|
|
expected_data = '''My test 1
|
|
depends_on:0
|
|
0:int:0:int:0xfa:exp:0:exp:1
|
|
|
|
My test 2
|
|
depends_on:0:1
|
|
1:char*:"yahoo":int:88:exp:0
|
|
|
|
'''
|
|
expected_expression_code = '''
|
|
case 0:
|
|
{
|
|
*out_value = MACRO1;
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
*out_value = MACRO2;
|
|
}
|
|
break;'''
|
|
self.assertEqual(dep_check_code, expected_dep_check_code)
|
|
self.assertEqual(out_data_f.getvalue(), expected_data)
|
|
self.assertEqual(expression_code, expected_expression_code)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest_main()
|