diff --git a/scripts/mbedtls_dev/bignum_common.py b/scripts/mbedtls_dev/bignum_common.py
index b942070..d8ef4a8 100644
--- a/scripts/mbedtls_dev/bignum_common.py
+++ b/scripts/mbedtls_dev/bignum_common.py
@@ -17,6 +17,7 @@
 from abc import abstractmethod
 import enum
 from typing import Iterator, List, Tuple, TypeVar, Any
+from copy import deepcopy
 from itertools import chain
 
 from . import test_case
@@ -104,6 +105,7 @@
     symbol = ""
     input_values = INPUTS_DEFAULT # type: List[str]
     input_cases = [] # type: List[Any]
+    dependencies = [] # type: List[Any]
     unique_combinations_only = False
     input_styles = ["variable", "fixed", "arch_split"] # type: List[str]
     input_style = "variable" # type: str
@@ -119,10 +121,11 @@
         # provides earlier/more robust input validation.
         self.int_a = hex_to_int(val_a)
         self.int_b = hex_to_int(val_b)
+        self.dependencies = deepcopy(self.dependencies)
         if bits_in_limb not in self.limb_sizes:
             raise ValueError("Invalid number of bits in limb!")
         if self.input_style == "arch_split":
-            self.dependencies = ["MBEDTLS_HAVE_INT{:d}".format(bits_in_limb)]
+            self.dependencies.append("MBEDTLS_HAVE_INT{:d}".format(bits_in_limb))
         self.bits_in_limb = bits_in_limb
 
     @property
diff --git a/scripts/mbedtls_dev/ecp.py b/scripts/mbedtls_dev/ecp.py
index 1c03205..d1d23c1 100644
--- a/scripts/mbedtls_dev/ecp.py
+++ b/scripts/mbedtls_dev/ecp.py
@@ -30,10 +30,11 @@
                    EcpTarget):
     """Test cases for ECP P192 fast reduction."""
     symbol = "-"
-    test_function = "ecp_mod_p192_raw"
+    test_function = "ecp_mod_p_generic_raw"
     test_name = "ecp_mod_p192_raw"
     input_style = "fixed"
     arity = 1
+    dependencies = ["MBEDTLS_ECP_DP_SECP192R1_ENABLED"]
 
     moduli = ["fffffffffffffffffffffffffffffffeffffffffffffffff"] # type: List[str]
 
@@ -96,15 +97,20 @@
     def is_valid(self) -> bool:
         return True
 
+    def arguments(self):
+        args = super().arguments()
+        return  ["MBEDTLS_ECP_DP_SECP192R1"] + args
+
 
 class EcpP224R1Raw(bignum_common.ModOperationCommon,
                    EcpTarget):
     """Test cases for ECP P224 fast reduction."""
     symbol = "-"
-    test_function = "ecp_mod_p224_raw"
+    test_function = "ecp_mod_p_generic_raw"
     test_name = "ecp_mod_p224_raw"
     input_style = "arch_split"
     arity = 1
+    dependencies = ["MBEDTLS_ECP_DP_SECP224R1_ENABLED"]
 
     moduli = ["ffffffffffffffffffffffffffffffff000000000000000000000001"] # type: List[str]
 
@@ -168,15 +174,20 @@
     def is_valid(self) -> bool:
         return True
 
+    def arguments(self):
+        args = super().arguments()
+        return  ["MBEDTLS_ECP_DP_SECP224R1"] + args
+
 
 class EcpP256R1Raw(bignum_common.ModOperationCommon,
                    EcpTarget):
     """Test cases for ECP P256 fast reduction."""
     symbol = "-"
-    test_function = "ecp_mod_p256_raw"
+    test_function = "ecp_mod_p_generic_raw"
     test_name = "ecp_mod_p256_raw"
     input_style = "fixed"
     arity = 1
+    dependencies = ["MBEDTLS_ECP_DP_SECP256R1_ENABLED"]
 
     moduli = ["ffffffff00000001000000000000000000000000ffffffffffffffffffffffff"] # type: List[str]
 
@@ -247,14 +258,19 @@
     def is_valid(self) -> bool:
         return True
 
+    def arguments(self):
+        args = super().arguments()
+        return  ["MBEDTLS_ECP_DP_SECP256R1"] + args
+
 
 class EcpP384R1Raw(bignum_common.ModOperationCommon,
                    EcpTarget):
     """Test cases for ECP P384 fast reduction."""
-    test_function = "ecp_mod_p384_raw"
+    test_function = "ecp_mod_p_generic_raw"
     test_name = "ecp_mod_p384_raw"
     input_style = "fixed"
     arity = 1
+    dependencies = ["MBEDTLS_ECP_DP_SECP384R1_ENABLED"]
 
     moduli = [("ffffffffffffffffffffffffffffffffffffffffffffffff"
                "fffffffffffffffeffffffff0000000000000000ffffffff")
@@ -364,13 +380,19 @@
     def is_valid(self) -> bool:
         return True
 
+    def arguments(self):
+        args = super().arguments()
+        return  ["MBEDTLS_ECP_DP_SECP384R1"] + args
+
+
 class EcpP521R1Raw(bignum_common.ModOperationCommon,
                    EcpTarget):
     """Test cases for ECP P521 fast reduction."""
-    test_function = "ecp_mod_p521_raw"
+    test_function = "ecp_mod_p_generic_raw"
     test_name = "ecp_mod_p521_raw"
     input_style = "arch_split"
     arity = 1
+    dependencies = ["MBEDTLS_ECP_DP_SECP521R1_ENABLED"]
 
     moduli = [("01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
                "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
@@ -462,3 +484,7 @@
     @property
     def is_valid(self) -> bool:
         return True
+
+    def arguments(self):
+        args = super().arguments()
+        return  ["MBEDTLS_ECP_DP_SECP521R1"] + args
diff --git a/tests/suites/test_suite_alignment.function b/tests/suites/test_suite_alignment.function
index f670331..b9ceb59 100644
--- a/tests/suites/test_suite_alignment.function
+++ b/tests/suites/test_suite_alignment.function
@@ -12,18 +12,15 @@
  */
 int parse_hex_string(char *hex_string, uint64_t *result)
 {
-    uint8_t raw[8];
+    uint8_t raw[8] = { 0 };
     size_t olen;
     if (mbedtls_test_unhexify(raw, sizeof(raw), hex_string, &olen) != 0) {
         return 0;
     }
+
     *result = 0;
     for (size_t i = 0; i < olen; i++) {
-        if (MBEDTLS_IS_BIG_ENDIAN) {
-            *result |= ((uint64_t) raw[i]) << (i * 8);
-        } else {
-            *result |= ((uint64_t) raw[i]) << ((olen - i - 1) * 8);
-        }
+        *result |= ((uint64_t) raw[i]) << ((olen - i - 1) * 8);
     }
     return 1;
 }
@@ -57,44 +54,29 @@
             break;
     }
 
-    /* Generate expected result */
+    /* Define expected result by manually aligning the raw bytes, and
+     * reading back with a normal pointer access. */
+    uint64_t raw_aligned_64;
+    uint16_t *raw_aligned_16 = (uint16_t *) &raw_aligned_64;
+    uint32_t *raw_aligned_32 = (uint32_t *) &raw_aligned_64;
+    memcpy(&raw_aligned_64, ((uint8_t *) &raw) + offset, size / 8);
+    /* Make a 16/32/64 byte read from the aligned location, and copy to expected */
     uint64_t expected = 0;
-    for (uint8_t i = 0; i < 8; i++) {
-        uint8_t shift;
-        if (MBEDTLS_IS_BIG_ENDIAN) {
-            /*
-             * Similar to little-endian case described below, but the shift needs
-             * to be inverted
-             */
-            shift = 7 - (i * 8);
-        } else {
-            /* example for offset == 1:
-             * expected = (( 1 + 0 ) << (0 * 8)) | (( 1 + 1 ) << (1 * 8)) | (( 1 + 2 ) << (2 * 8)))
-             *          = (1 << 0) | (2 << 8) | (3 << 16) ...
-             *          = 0x0807060504030201
-             * x = { 0, 1, 2, 3, ... }
-             * ie expected is the value that would be read from x on a LE system, when
-             * byte swapping is not performed
-             */
-            shift = i * 8;
-        }
-        uint64_t b = offset + i;
-        expected |= b << shift;
-    }
-
-    /* Mask out excess bits from expected result */
     switch (size) {
         case 16:
-            expected &= 0xffff;
+            expected = *raw_aligned_16;
             break;
         case 32:
-            expected &= 0xffffffff;
+            expected = *raw_aligned_32;
+            break;
+        case 64:
+            expected = raw_aligned_64;
             break;
     }
 
     TEST_EQUAL(r, expected);
 
-    /* Write sentinel to the part of the array we will testing writing to */
+    /* Write sentinel to the part of the array we will test writing to */
     for (size_t i = 0; i < (size_t) (size / 8); i++) {
         x[i + offset] = 0xff;
     }
@@ -122,7 +104,7 @@
 /* BEGIN_CASE */
 void mbedtls_byteswap(char *input_str, int size, char *expected_str)
 {
-    uint64_t input, expected;
+    uint64_t input = 0, expected = 0;
     TEST_ASSERT(parse_hex_string(input_str, &input));
     TEST_ASSERT(parse_hex_string(expected_str, &expected));
 
@@ -315,7 +297,7 @@
     /* Verify read */
     TEST_EQUAL(read, expected);
 
-    /* Test writing back to memory. First write sentiel */
+    /* Test writing back to memory. First write sentinel */
     for (size_t i = 0; i < (size_t) (size / 8); i++) {
         x[i + offset] = 0xff;
     }
diff --git a/tests/suites/test_suite_ecp.function b/tests/suites/test_suite_ecp.function
index fa35a29..87cd0f3 100644
--- a/tests/suites/test_suite_ecp.function
+++ b/tests/suites/test_suite_ecp.function
@@ -1266,10 +1266,11 @@
 }
 /* END_CASE */
 
-/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP192R1_ENABLED */
-void ecp_mod_p192_raw(char *input_N,
-                      char *input_X,
-                      char *result)
+/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS */
+void ecp_mod_p_generic_raw(int curve_id,
+                           char *input_N,
+                           char *input_X,
+                           char *result)
 {
     mbedtls_mpi_uint *X = NULL;
     mbedtls_mpi_uint *N = NULL;
@@ -1278,48 +1279,10 @@
     size_t limbs_N;
     size_t limbs_res;
 
-    mbedtls_mpi_mod_modulus m;
-    mbedtls_mpi_mod_modulus_init(&m);
-
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&X,   &limbs_X,   input_X), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&N,   &limbs_N,   input_N), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result),  0);
-
-    size_t limbs = limbs_N;
-    size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
-
-    TEST_EQUAL(limbs_X, 2 * limbs);
-    TEST_EQUAL(limbs_res, limbs);
-
-    TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
-                   &m, N, limbs,
-                   MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
-
-    TEST_EQUAL(mbedtls_ecp_mod_p192_raw(X, limbs_X), 0);
-    TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 192);
-    mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
-    ASSERT_COMPARE(X, bytes, res, bytes);
-
-exit:
-    mbedtls_free(X);
-    mbedtls_free(res);
-
-    mbedtls_mpi_mod_modulus_free(&m);
-    mbedtls_free(N);
-}
-/* END_CASE */
-
-/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP224R1_ENABLED */
-void ecp_mod_p224_raw(char *input_N,
-                      char *input_X,
-                      char *result)
-{
-    mbedtls_mpi_uint *X = NULL;
-    mbedtls_mpi_uint *N = NULL;
-    mbedtls_mpi_uint *res = NULL;
-    size_t limbs_X;
-    size_t limbs_N;
-    size_t limbs_res;
+    size_t bytes;
+    size_t limbs;
+    size_t curve_bits;
+    int (*curve_func)(mbedtls_mpi_uint *X, size_t X_limbs);
 
     mbedtls_mpi_mod_modulus m;
     mbedtls_mpi_mod_modulus_init(&m);
@@ -1327,148 +1290,59 @@
     TEST_EQUAL(mbedtls_test_read_mpi_core(&X,   &limbs_X,   input_X), 0);
     TEST_EQUAL(mbedtls_test_read_mpi_core(&N,   &limbs_N,   input_N), 0);
     TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result),  0);
+    bytes = limbs_N * sizeof(mbedtls_mpi_uint);
 
-    size_t limbs = limbs_N;
-    size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
+    switch (curve_id) {
+#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
+        case MBEDTLS_ECP_DP_SECP192R1:
+            limbs = 2 * limbs_N;
+            curve_bits = 192;
+            curve_func = &mbedtls_ecp_mod_p192_raw;
+            break;
+#endif
+#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
+        case MBEDTLS_ECP_DP_SECP224R1:
+            limbs = 448 / biL;
+            curve_bits = 224;
+            curve_func = &mbedtls_ecp_mod_p224_raw;
+            break;
+#endif
+#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
+        case MBEDTLS_ECP_DP_SECP256R1:
+            limbs = 2 * limbs_N;
+            curve_bits = 256;
+            curve_func = &mbedtls_ecp_mod_p256_raw;
+            break;
+#endif
+#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
+        case MBEDTLS_ECP_DP_SECP384R1:
+            limbs = 2 * limbs_N;
+            curve_bits = 384;
+            curve_func = &mbedtls_ecp_mod_p384_raw;
+            break;
+#endif
+#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
+        case MBEDTLS_ECP_DP_SECP521R1:
+            limbs = 2 * limbs_N;
+            curve_bits = 522;
+            curve_func = &mbedtls_ecp_mod_p521_raw;
+            break;
+#endif
+        default:
+            mbedtls_test_fail("Unsupported curve_id", __LINE__, __FILE__);
+            goto exit;
+    }
 
-    TEST_EQUAL(limbs_X, 448 / biL);
-    TEST_EQUAL(limbs_res, limbs);
+    TEST_EQUAL(limbs_X, limbs);
+    TEST_EQUAL(limbs_res, limbs_N);
 
     TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
-                   &m, N, limbs,
-                   MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
+                   &m, N, limbs_N,
+                   MBEDTLS_MPI_MOD_REP_OPT_RED), 0);
 
-    TEST_EQUAL(mbedtls_ecp_mod_p224_raw(X, limbs_X), 0);
-    TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 224);
-    mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
-    ASSERT_COMPARE(X, bytes, res, bytes);
+    TEST_EQUAL((*curve_func)(X, limbs_X), 0);
 
-exit:
-    mbedtls_free(X);
-    mbedtls_free(res);
-
-    mbedtls_mpi_mod_modulus_free(&m);
-    mbedtls_free(N);
-}
-/* END_CASE */
-
-/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
-void ecp_mod_p256_raw(char *input_N,
-                      char *input_X,
-                      char *result)
-{
-    mbedtls_mpi_uint *X = NULL;
-    mbedtls_mpi_uint *N = NULL;
-    mbedtls_mpi_uint *res = NULL;
-    size_t limbs_X;
-    size_t limbs_N;
-    size_t limbs_res;
-
-    mbedtls_mpi_mod_modulus m;
-    mbedtls_mpi_mod_modulus_init(&m);
-
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&X,   &limbs_X,   input_X), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&N,   &limbs_N,   input_N), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result),  0);
-
-    size_t limbs = limbs_N;
-    size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
-
-    TEST_EQUAL(limbs_X, 2 * limbs);
-    TEST_EQUAL(limbs_res, limbs);
-
-    TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
-                   &m, N, limbs,
-                   MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
-
-    TEST_EQUAL(mbedtls_ecp_mod_p256_raw(X, limbs_X), 0);
-    TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 256);
-    mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
-    ASSERT_COMPARE(X, bytes, res, bytes);
-
-exit:
-    mbedtls_free(X);
-    mbedtls_free(res);
-
-    mbedtls_mpi_mod_modulus_free(&m);
-    mbedtls_free(N);
-}
-/* END_CASE */
-
-/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP384R1_ENABLED */
-void ecp_mod_p384_raw(char *input_N,
-                      char *input_X,
-                      char *result)
-{
-    mbedtls_mpi_uint *X = NULL;
-    mbedtls_mpi_uint *N = NULL;
-    mbedtls_mpi_uint *res = NULL;
-    size_t limbs_X;
-    size_t limbs_N;
-    size_t limbs_res;
-
-    mbedtls_mpi_mod_modulus m;
-    mbedtls_mpi_mod_modulus_init(&m);
-
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&X,   &limbs_X,   input_X), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&N,   &limbs_N,   input_N), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result),  0);
-
-    size_t limbs = limbs_N;
-    size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
-
-    TEST_EQUAL(limbs_X, 2 * limbs);
-    TEST_EQUAL(limbs_res, limbs);
-
-    TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
-                   &m, N, limbs,
-                   MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
-
-    TEST_EQUAL(mbedtls_ecp_mod_p384_raw(X, limbs_X), 0);
-    TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 384);
-    mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
-    ASSERT_COMPARE(X, bytes, res, bytes);
-
-exit:
-    mbedtls_free(X);
-    mbedtls_free(res);
-
-    mbedtls_mpi_mod_modulus_free(&m);
-    mbedtls_free(N);
-}
-/* END_CASE */
-
-/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP521R1_ENABLED */
-void ecp_mod_p521_raw(char *input_N,
-                      char *input_X,
-                      char *result)
-{
-    mbedtls_mpi_uint *X = NULL;
-    mbedtls_mpi_uint *N = NULL;
-    mbedtls_mpi_uint *res = NULL;
-    size_t limbs_X;
-    size_t limbs_N;
-    size_t limbs_res;
-
-    mbedtls_mpi_mod_modulus m;
-    mbedtls_mpi_mod_modulus_init(&m);
-
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&X,   &limbs_X,   input_X), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&N,   &limbs_N,   input_N), 0);
-    TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result),  0);
-
-    size_t limbs = limbs_N;
-    size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
-
-    TEST_EQUAL(limbs_X, 2 * limbs);
-    TEST_EQUAL(limbs_res, limbs);
-
-    TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
-                   &m, N, limbs,
-                   MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
-
-    TEST_EQUAL(mbedtls_ecp_mod_p521_raw(X, limbs_X), 0);
-    TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 522);
+    TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), curve_bits);
     mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
     ASSERT_COMPARE(X, bytes, res, bytes);