Add module for bignum_core test generation
Separate file is added for classes used to generate cases for tests
in bignum_core.function. Common elements of the BignumOperation class
are added to classes in a new common file, for use across files.
Signed-off-by: Werner Lewis <werner.lewis@arm.com>
diff --git a/scripts/mbedtls_dev/bignum_common.py b/scripts/mbedtls_dev/bignum_common.py
new file mode 100644
index 0000000..b20fe81
--- /dev/null
+++ b/scripts/mbedtls_dev/bignum_common.py
@@ -0,0 +1,111 @@
+"""Common features for bignum in test generation framework."""
+# 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 itertools
+import typing
+
+from abc import abstractmethod
+from typing import Iterator, List, Tuple, TypeVar
+
+T = TypeVar('T') #pylint: disable=invalid-name
+
+def hex_to_int(val: str) -> int:
+ return int(val, 16) if val else 0
+
+def quote_str(val) -> str:
+ return "\"{}\"".format(val)
+
+def bound_mpi8(val: int) -> int:
+ """First number exceeding 8-byte limbs needed for given input value."""
+ return bound_mpi8_limbs(limbs_mpi8(val))
+
+def bound_mpi4(val: int) -> int:
+ """First number exceeding 4-byte limbs needed for given input value."""
+ return bound_mpi4_limbs(limbs_mpi4(val))
+
+def bound_mpi8_limbs(limbs: int) -> int:
+ """First number exceeding maximum of given 8-byte limbs."""
+ bits = 64 * limbs
+ return 1 << bits
+
+def bound_mpi4_limbs(limbs: int) -> int:
+ """First number exceeding maximum of given 4-byte limbs."""
+ bits = 32 * limbs
+ return 1 << bits
+
+def limbs_mpi8(val: int) -> int:
+ """Return the number of 8-byte limbs required to store value."""
+ return (val.bit_length() + 63) // 64
+
+def limbs_mpi4(val: int) -> int:
+ """Return the number of 4-byte limbs required to store value."""
+ return (val.bit_length() + 31) // 32
+
+def combination_pairs(values: List[T]) -> List[Tuple[T, T]]:
+ """Return all pair combinations from input values.
+
+ The return value is cast, as older versions of mypy are unable to derive
+ the specific type returned by itertools.combinations_with_replacement.
+ """
+ return typing.cast(
+ List[Tuple[T, T]],
+ list(itertools.combinations_with_replacement(values, 2))
+ )
+
+
+class OperationCommon:
+ """Common features for bignum binary operations.
+
+ This adds functionality common in binary operation tests.
+
+ Attributes:
+ symbol: Symbol to use for the operation in case description.
+ input_values: List of values to use as test case inputs. These are
+ combined to produce pairs of values.
+ input_cases: List of tuples containing pairs of test case inputs. This
+ can be used to implement specific pairs of inputs.
+ """
+ symbol = ""
+ input_values = [] # type: List[str]
+ input_cases = [] # type: List[Tuple[str, str]]
+
+ def __init__(self, val_a: str, val_b: str) -> None:
+ self.arg_a = val_a
+ self.arg_b = val_b
+ self.int_a = hex_to_int(val_a)
+ self.int_b = hex_to_int(val_b)
+
+ def arguments(self) -> List[str]:
+ return [quote_str(self.arg_a), quote_str(self.arg_b), self.result()]
+
+ @abstractmethod
+ def result(self) -> str:
+ """Get the result of the operation.
+
+ This could be calculated during initialization and stored as `_result`
+ and then returned, or calculated when the method is called.
+ """
+ raise NotImplementedError
+
+ @classmethod
+ def get_value_pairs(cls) -> Iterator[Tuple[str, str]]:
+ """Generator to yield pairs of inputs.
+
+ Combinations are first generated from all input values, and then
+ specific cases provided.
+ """
+ yield from combination_pairs(cls.input_values)
+ yield from cls.input_cases
diff --git a/scripts/mbedtls_dev/bignum_core.py b/scripts/mbedtls_dev/bignum_core.py
new file mode 100644
index 0000000..b30f858
--- /dev/null
+++ b/scripts/mbedtls_dev/bignum_core.py
@@ -0,0 +1,72 @@
+"""Framework classes for generation of bignum core test cases."""
+# 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.
+
+from abc import ABCMeta
+from typing import Iterator
+
+from . import test_case
+from . import test_data_generation
+from . import bignum_common
+
+
+class BignumCoreTarget(test_data_generation.BaseTarget, metaclass=ABCMeta):
+ #pylint: disable=abstract-method
+ """Target for bignum core test case generation."""
+ target_basename = 'test_suite_bignum_core.generated'
+
+
+class BignumCoreOperation(bignum_common.OperationCommon, BignumCoreTarget, metaclass=ABCMeta):
+ #pylint: disable=abstract-method
+ """Common features for bignum core operations."""
+ input_values = [
+ "0", "1", "3", "f", "fe", "ff", "100", "ff00", "fffe", "ffff", "10000",
+ "fffffffe", "ffffffff", "100000000", "1f7f7f7f7f7f7f",
+ "8000000000000000", "fefefefefefefefe", "fffffffffffffffe",
+ "ffffffffffffffff", "10000000000000000", "1234567890abcdef0",
+ "fffffffffffffffffefefefefefefefe", "fffffffffffffffffffffffffffffffe",
+ "ffffffffffffffffffffffffffffffff", "100000000000000000000000000000000",
+ "1234567890abcdef01234567890abcdef0",
+ "fffffffffffffffffffffffffffffffffffffffffffffffffefefefefefefefe",
+ "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe",
+ "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+ "10000000000000000000000000000000000000000000000000000000000000000",
+ "1234567890abcdef01234567890abcdef01234567890abcdef01234567890abcdef0",
+ (
+ "4df72d07b4b71c8dacb6cffa954f8d88254b6277099308baf003fab73227f34029"
+ "643b5a263f66e0d3c3fa297ef71755efd53b8fb6cb812c6bbf7bcf179298bd9947"
+ "c4c8b14324140a2c0f5fad7958a69050a987a6096e9f055fb38edf0c5889eca4a0"
+ "cfa99b45fbdeee4c696b328ddceae4723945901ec025076b12b"
+ )
+ ]
+
+ def description(self) -> str:
+ """Generate a description for the test case.
+
+ If not set, case_description uses the form A `symbol` B, where symbol
+ is used to represent the operation. Descriptions of each value are
+ generated to provide some context to the test case.
+ """
+ if not self.case_description:
+ self.case_description = "{} {} {}".format(
+ self.arg_a, self.symbol, self.arg_b
+ )
+ return super().description()
+
+ @classmethod
+ def generate_function_tests(cls) -> Iterator[test_case.TestCase]:
+ for a_value, b_value in cls.get_value_pairs():
+ yield cls(a_value, b_value).create_test_case()
+
diff --git a/scripts/mbedtls_dev/test_data_generation.py b/scripts/mbedtls_dev/test_data_generation.py
index cdb1c03..eec0f9d 100644
--- a/scripts/mbedtls_dev/test_data_generation.py
+++ b/scripts/mbedtls_dev/test_data_generation.py
@@ -148,6 +148,7 @@
self.targets.update({
subclass.target_basename: subclass.generate_tests
for subclass in BaseTarget.__subclasses__()
+ if subclass.target_basename
})
def filename_for(self, basename: str) -> str: