1#!/usr/bin/env python3
2"""Generate test data for bignum functions.
3
4With no arguments, generate all test data. With non-option arguments,
5generate only the specified files.
6
7Class structure:
8
9Child classes of test_data_generation.BaseTarget (file targets) represent an output
10file. These indicate where test cases will be written to, for all subclasses of
11this target. Multiple file targets should not reuse a `target_basename`.
12
13Each subclass derived from a file target can either be:
14  - A concrete class, representing a test function, which generates test cases.
15  - An abstract class containing shared methods and attributes, not associated
16        with a test function. An example is BignumOperation, which provides
17        common features used for bignum binary operations.
18
19Both concrete and abstract subclasses can be derived from, to implement
20additional test cases (see BignumCmp and BignumCmpAbs for examples of deriving
21from abstract and concrete classes).
22
23
24Adding test case generation for a function:
25
26A subclass representing the test function should be added, deriving from a
27file target such as BignumTarget. This test class must set/implement the
28following:
29  - test_function: the function name from the associated .function file.
30  - test_name: a descriptive name or brief summary to refer to the test
31        function.
32  - arguments(): a method to generate the list of arguments required for the
33        test_function.
34  - generate_function_tests(): a method to generate TestCases for the function.
35        This should create instances of the class with required input data, and
36        call `.create_test_case()` to yield the TestCase.
37
38Additional details and other attributes/methods are given in the documentation
39of BaseTarget in test_data_generation.py.
40"""
41
42# Copyright The Mbed TLS Contributors
43# SPDX-License-Identifier: Apache-2.0
44#
45# Licensed under the Apache License, Version 2.0 (the "License"); you may
46# not use this file except in compliance with the License.
47# You may obtain a copy of the License at
48#
49# http://www.apache.org/licenses/LICENSE-2.0
50#
51# Unless required by applicable law or agreed to in writing, software
52# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
53# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
54# See the License for the specific language governing permissions and
55# limitations under the License.
56
57import sys
58
59from abc import ABCMeta
60from typing import List
61
62import scripts_path # pylint: disable=unused-import
63from mbedtls_dev import test_data_generation
64from mbedtls_dev import bignum_common
65# Import modules containing additional test classes
66# Test function classes in these modules will be registered by
67# the framework
68from mbedtls_dev import bignum_core, bignum_mod_raw, bignum_mod # pylint: disable=unused-import
69
70class BignumTarget(test_data_generation.BaseTarget):
71    #pylint: disable=too-few-public-methods
72    """Target for bignum (legacy) test case generation."""
73    target_basename = 'test_suite_bignum.generated'
74
75
76class BignumOperation(bignum_common.OperationCommon, BignumTarget,
77                      metaclass=ABCMeta):
78    #pylint: disable=abstract-method
79    """Common features for bignum operations in legacy tests."""
80    unique_combinations_only = True
81    input_values = [
82        "", "0", "-", "-0",
83        "7b", "-7b",
84        "0000000000000000123", "-0000000000000000123",
85        "1230000000000000000", "-1230000000000000000"
86    ]
87
88    def description_suffix(self) -> str:
89        #pylint: disable=no-self-use # derived classes need self
90        """Text to add at the end of the test case description."""
91        return ""
92
93    def description(self) -> str:
94        """Generate a description for the test case.
95
96        If not set, case_description uses the form A `symbol` B, where symbol
97        is used to represent the operation. Descriptions of each value are
98        generated to provide some context to the test case.
99        """
100        if not self.case_description:
101            self.case_description = "{} {} {}".format(
102                self.value_description(self.arg_a),
103                self.symbol,
104                self.value_description(self.arg_b)
105            )
106            description_suffix = self.description_suffix()
107            if description_suffix:
108                self.case_description += " " + description_suffix
109        return super().description()
110
111    @staticmethod
112    def value_description(val) -> str:
113        """Generate a description of the argument val.
114
115        This produces a simple description of the value, which is used in test
116        case naming to add context.
117        """
118        if val == "":
119            return "0 (null)"
120        if val == "-":
121            return "negative 0 (null)"
122        if val == "0":
123            return "0 (1 limb)"
124
125        if val[0] == "-":
126            tmp = "negative"
127            val = val[1:]
128        else:
129            tmp = "positive"
130        if val[0] == "0":
131            tmp += " with leading zero limb"
132        elif len(val) > 10:
133            tmp = "large " + tmp
134        return tmp
135
136
137class BignumCmp(BignumOperation):
138    """Test cases for bignum value comparison."""
139    count = 0
140    test_function = "mpi_cmp_mpi"
141    test_name = "MPI compare"
142    input_cases = [
143        ("-2", "-3"),
144        ("-2", "-2"),
145        ("2b4", "2b5"),
146        ("2b5", "2b6")
147        ]
148
149    def __init__(self, val_a, val_b) -> None:
150        super().__init__(val_a, val_b)
151        self._result = int(self.int_a > self.int_b) - int(self.int_a < self.int_b)
152        self.symbol = ["<", "==", ">"][self._result + 1]
153
154    def result(self) -> List[str]:
155        return [str(self._result)]
156
157
158class BignumCmpAbs(BignumCmp):
159    """Test cases for absolute bignum value comparison."""
160    count = 0
161    test_function = "mpi_cmp_abs"
162    test_name = "MPI compare (abs)"
163
164    def __init__(self, val_a, val_b) -> None:
165        super().__init__(val_a.strip("-"), val_b.strip("-"))
166
167
168class BignumAdd(BignumOperation):
169    """Test cases for bignum value addition."""
170    count = 0
171    symbol = "+"
172    test_function = "mpi_add_mpi"
173    test_name = "MPI add"
174    input_cases = bignum_common.combination_pairs(
175        [
176            "1c67967269c6", "9cde3",
177            "-1c67967269c6", "-9cde3",
178        ]
179    )
180
181    def __init__(self, val_a: str, val_b: str) -> None:
182        super().__init__(val_a, val_b)
183        self._result = self.int_a + self.int_b
184
185    def description_suffix(self) -> str:
186        if (self.int_a >= 0 and self.int_b >= 0):
187            return "" # obviously positive result or 0
188        if (self.int_a <= 0 and self.int_b <= 0):
189            return "" # obviously negative result or 0
190        # The sign of the result is not obvious, so indicate it
191        return ", result{}0".format('>' if self._result > 0 else
192                                    '<' if self._result < 0 else '=')
193
194    def result(self) -> List[str]:
195        return [bignum_common.quote_str("{:x}".format(self._result))]
196
197if __name__ == '__main__':
198    # Use the section of the docstring relevant to the CLI as description
199    test_data_generation.main(sys.argv[1:], "\n".join(__doc__.splitlines()[:4]))
200