Bignum Tests: remove ModOperationCommonArchSplit

The functionality of ModOperationCommonArchSplit is needed in several
subclasses, therefore moving it to a superclass.

There is another, redundant ArchSplit class, which will be removed in a
later commit.

Signed-off-by: Janos Follath <janos.follath@arm.com>

scripts/mbedtls_dev/bignum_common.py

@@ -80,17 +80,29 @@ class OperationCommon(test_data_generation.BaseTest):
         unique_combinations_only: Boolean to select if test case combinations
             must be unique. If True, only A,B or B,A would be included as a test
             case. If False, both A,B and B,A would be included.
+        arch_split: Boolean to select if different test cases are needed
+            depending on the architecture/limb size. This will cause test
+            objects being generated with different architectures. Individual
+            test objects can tell their architecture by accessing the
+            bits_in_limb instance variable.
     """
     symbol = ""
     input_values = [] # type: List[str]
     input_cases = [] # type: List[Tuple[str, str]]
     unique_combinations_only = True
+    arch_split = False
+    limb_sizes = [32, 64] # type: List[int]
 
-    def __init__(self, val_a: str, val_b: str) -> None:
+    def __init__(self, val_a: str, val_b: str, bits_in_limb: int = 64) -> 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)
+        if bits_in_limb not in self.limb_sizes:
+            raise ValueError("Invalid number of bits in limb!")
+        if self.arch_split:
+            self.dependencies = ["MBEDTLS_HAVE_INT{:d}".format(bits_in_limb)]
+        self.bits_in_limb = bits_in_limb
 
     def arguments(self) -> List[str]:
         return [
@@ -139,17 +151,22 @@ class OperationCommon(test_data_generation.BaseTest):
     @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()
+            if cls.arch_split:
+                for bil in cls.limb_sizes:
+                    yield cls(a_value, b_value,
+                              bits_in_limb=bil).create_test_case()
+            else:
+                yield cls(a_value, b_value).create_test_case()
 
 
 class ModOperationCommon(OperationCommon):
     #pylint: disable=abstract-method
     """Target for bignum mod_raw test case generation."""
 
-    def __init__(self, val_n: str, val_a: str, val_b: str = "0", bits_in_limb: int = 64) -> None:
-        super().__init__(val_a=val_a, val_b=val_b)
+    def __init__(self, val_n: str, val_a: str, val_b: str = "0",
+                 bits_in_limb: int = 64) -> None:
+        super().__init__(val_a=val_a, val_b=val_b, bits_in_limb=bits_in_limb)
         self.val_n = val_n
-        self.bits_in_limb = bits_in_limb
 
     @property
     def int_n(self) -> int:
@@ -226,28 +243,6 @@ class OperationCommonArchSplit(OperationCommon):
             yield cls(a_value, b_value, 64).create_test_case()
 
 
-class ModOperationCommonArchSplit(ModOperationCommon):
-    #pylint: disable=abstract-method
-    """Common features for bignum mod raw operations where the result depends on
-    the limb size."""
-
-    limb_sizes = [32, 64] # type: List[int]
-
-    def __init__(self, val_n: str, val_a: str, val_b: str = "0", bits_in_limb: int = 64) -> None:
-        super().__init__(val_n=val_n, val_a=val_a, val_b=val_b, bits_in_limb=bits_in_limb)
-
-        if bits_in_limb not in self.limb_sizes:
-            raise ValueError("Invalid number of bits in limb!")
-
-        self.dependencies = ["MBEDTLS_HAVE_INT{:d}".format(bits_in_limb)]
-
-    @classmethod
-    def generate_function_tests(cls) -> Iterator[test_case.TestCase]:
-        for a_value, b_value in cls.get_value_pairs():
-            for bil in cls.limb_sizes:
-                yield cls(a_value, b_value, bits_in_limb=bil).create_test_case()
-
-
 # BEGIN MERGE SLOT 1
 
 # END MERGE SLOT 1

scripts/mbedtls_dev/bignum_mod_raw.py

@@ -50,12 +50,13 @@ class BignumModRawTarget(test_data_generation.BaseTarget):
 # END MERGE SLOT 6
 
 # BEGIN MERGE SLOT 7
-class BignumModRawConvertToMont(bignum_common.ModOperationCommonArchSplit,
+class BignumModRawConvertToMont(bignum_common.ModOperationCommon,
                                 BignumModRawTarget):
     """ Test cases for mpi_mod_raw_to_mont_rep(). """
 
     test_function = "mpi_mod_raw_to_mont_rep"
     test_name = "Convert into Mont: "
+    arch_split = True
 
     test_data_moduli = ["b",
                         "fd",