From 545911f751d972ef6b0b0634d5a1ecedb845ebfb Mon Sep 17 00:00:00 2001 From: Werner Lewis Date: Fri, 8 Jul 2022 13:54:57 +0100 Subject: [PATCH] Add bignum test generation framework Adds python script for generation of bignum test cases, with initial classes for mpi_cmp_mpi test cases. Build scripts are updated to generate test data. Signed-off-by: Werner Lewis --- tests/scripts/check-generated-files.sh | 1 + tests/scripts/generate_bignum_tests.py | 269 +++++++++++++++++++++++++ 2 files changed, 270 insertions(+) create mode 100755 tests/scripts/generate_bignum_tests.py diff --git a/tests/scripts/check-generated-files.sh b/tests/scripts/check-generated-files.sh index 75730ba254..3e5cb86c98 100755 --- a/tests/scripts/check-generated-files.sh +++ b/tests/scripts/check-generated-files.sh @@ -107,4 +107,5 @@ check scripts/generate_query_config.pl programs/test/query_config.c check scripts/generate_features.pl library/version_features.c check scripts/generate_visualc_files.pl visualc/VS2010 check scripts/generate_psa_constants.py programs/psa/psa_constant_names_generated.c +check tests/scripts/generate_bignum_tests.py $(tests/scripts/generate_bignum_tests.py --list) check tests/scripts/generate_psa_tests.py $(tests/scripts/generate_psa_tests.py --list) diff --git a/tests/scripts/generate_bignum_tests.py b/tests/scripts/generate_bignum_tests.py new file mode 100755 index 0000000000..c6e6a116ca --- /dev/null +++ b/tests/scripts/generate_bignum_tests.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python3 +"""Generate test data for bignum functions. + +With no arguments, generate all test data. With non-option arguments, +generate only the specified files. +""" + +# Copyright The Mbed TLS Contributors +# SPDX-License-Identifier: Apache-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. + +import argparse +import itertools +import os +import posixpath +import re +import sys +from typing import Iterable, Iterator, Optional, Tuple, TypeVar + +import scripts_path # pylint: disable=unused-import +from mbedtls_dev import build_tree +from mbedtls_dev import test_case + +T = TypeVar('T') #pylint: disable=invalid-name + +def hex_to_int(val): + return int(val, 16) if val else 0 + +def quote_str(val): + return "\"{}\"".format(val) + + +class BaseTarget: + """Base target for test case generation. + + Attributes: + count: Counter for test class. + desc: Short description of test case. + func: Function which the class generates tests for. + gen_file: File to write generated tests to. + title: Description of the test function/purpose. + """ + count = 0 + desc = None + func = None + gen_file = "" + title = None + + def __init__(self) -> None: + type(self).count += 1 + + @property + def args(self) -> Iterable[str]: + """Create list of arguments for test case.""" + return [] + + @property + def description(self) -> str: + """Create a numbered test description.""" + return "{} #{} {}".format(self.title, self.count, self.desc) + + def create_test_case(self) -> test_case.TestCase: + """Generate test case from the current object.""" + tc = test_case.TestCase() + tc.set_description(self.description) + tc.set_function(self.func) + tc.set_arguments(self.args) + + return tc + + @classmethod + def generate_tests(cls): + """Generate test cases for the target subclasses.""" + for subclass in cls.__subclasses__(): + yield from subclass.generate_tests() + + +class BignumTarget(BaseTarget): + """Target for bignum (mpi) test case generation.""" + gen_file = 'test_suite_mpi.generated' + + +class BignumOperation(BignumTarget): + """Common features for test cases covering bignum operations. + + Attributes: + symb: Symbol used for operation in description. + input_vals: List of values used to generate test case args. + input_cases: List of tuples containing test case inputs. This + can be used to implement specific pairs of inputs. + """ + symb = "" + input_vals = [ + "", "0", "7b", "-7b", + "0000000000000000123", "-0000000000000000123", + "1230000000000000000", "-1230000000000000000" + ] + input_cases = [] + + def __init__(self, val_l: str, val_r: str) -> None: + super().__init__() + + self.arg_l = val_l + self.arg_r = val_r + self.int_l = hex_to_int(val_l) + self.int_r = hex_to_int(val_r) + + @property + def args(self): + return [quote_str(self.arg_l), quote_str(self.arg_r), self.result] + + @property + def description(self): + desc = self.desc if self.desc else "{} {} {}".format( + self.val_desc(self.arg_l), + self.symb, + self.val_desc(self.arg_r) + ) + return "{} #{} {}".format(self.title, self.count, desc) + + @property + def result(self) -> Optional[str]: + return None + + @staticmethod + def val_desc(val) -> str: + """Generate description of the argument val.""" + if val == "": + return "0 (null)" + if val == "0": + return "0 (1 limb)" + + if val[0] == "-": + tmp = "negative" + val = val[1:] + else: + tmp = "positive" + if val[0] == "0": + tmp += " with leading zero limb" + elif len(val) > 10: + tmp = "large " + tmp + return tmp + + @classmethod + def get_value_pairs(cls) -> Iterator[Tuple[str, ...]]: + """Generate value pairs.""" + for pair in set( + list(itertools.combinations(cls.input_vals, 2)) + + cls.input_cases + ): + yield pair + + @classmethod + def generate_tests(cls) -> Iterator[test_case.TestCase]: + if cls.func is not None: + # Generate tests for the current class + for l_value, r_value in cls.get_value_pairs(): + cur_op = cls(l_value, r_value) + yield cur_op.create_test_case() + # Once current class completed, check descendants + yield from super().generate_tests() + + +class BignumCmp(BignumOperation): + """Target for bignum comparison test cases.""" + count = 0 + func = "mbedtls_mpi_cmp_mpi" + title = "MPI compare" + input_cases = [ + ("-2", "-3"), + ("-2", "-2"), + ("2b4", "2b5"), + ("2b5", "2b6") + ] + + def __init__(self, val_l, val_r): + super().__init__(val_l, val_r) + self._result = (self.int_l > self.int_r) - (self.int_l < self.int_r) + self.symb = ["<", "==", ">"][self._result + 1] + + @property + def result(self): + return str(self._result) + + +class TestGenerator: + """Generate test data.""" + + def __init__(self, options) -> None: + self.test_suite_directory = self.get_option(options, 'directory', + 'tests/suites') + + @staticmethod + def get_option(options, name: str, default: T) -> T: + value = getattr(options, name, None) + return default if value is None else value + + def filename_for(self, basename: str) -> str: + """The location of the data file with the specified base name.""" + return posixpath.join(self.test_suite_directory, basename + '.data') + + def write_test_data_file(self, basename: str, + test_cases: Iterable[test_case.TestCase]) -> None: + """Write the test cases to a .data file. + + The output file is ``basename + '.data'`` in the test suite directory. + """ + filename = self.filename_for(basename) + test_case.write_data_file(filename, test_cases) + + # Note that targets whose names contain 'test_format' have their content + # validated by `abi_check.py`. + TARGETS = { + subclass.gen_file: subclass.generate_tests for subclass in + BaseTarget.__subclasses__() + } + + def generate_target(self, name: str) -> None: + test_cases = self.TARGETS[name]() + self.write_test_data_file(name, test_cases) + +def main(args): + """Command line entry point.""" + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--list', action='store_true', + help='List available targets and exit') + parser.add_argument('--list-for-cmake', action='store_true', + help='Print \';\'-separated list of available targets and exit') + parser.add_argument('--directory', metavar='DIR', + help='Output directory (default: tests/suites)') + parser.add_argument('targets', nargs='*', metavar='TARGET', + help='Target file to generate (default: all; "-": none)') + options = parser.parse_args(args) + build_tree.chdir_to_root() + generator = TestGenerator(options) + if options.list: + for name in sorted(generator.TARGETS): + print(generator.filename_for(name)) + return + # List in a cmake list format (i.e. ';'-separated) + if options.list_for_cmake: + print(';'.join(generator.filename_for(name) + for name in sorted(generator.TARGETS)), end='') + return + if options.targets: + # Allow "-" as a special case so you can run + # ``generate_bignum_tests.py - $targets`` and it works uniformly whether + # ``$targets`` is empty or not. + options.targets = [os.path.basename(re.sub(r'\.data\Z', r'', target)) + for target in options.targets + if target != '-'] + else: + options.targets = sorted(generator.TARGETS) + for target in options.targets: + generator.generate_target(target) + +if __name__ == '__main__': + main(sys.argv[1:])