diff --git a/tests/include/test/drivers/aead.h b/tests/include/test/drivers/aead.h
index 1be8910..2207cb3 100644
--- a/tests/include/test/drivers/aead.h
+++ b/tests/include/test/drivers/aead.h
@@ -37,18 +37,19 @@
     unsigned long hits;
     /* Status returned by the last AEAD driver function call. */
     psa_status_t driver_status;
-} test_driver_aead_hooks_t;
+} mbedtls_test_driver_aead_hooks_t;
 
-#define TEST_DRIVER_AEAD_INIT { 0, 0, 0 }
-static inline test_driver_aead_hooks_t test_driver_aead_hooks_init( void )
+#define MBEDTLS_TEST_DRIVER_AEAD_INIT { 0, 0, 0 }
+static inline mbedtls_test_driver_aead_hooks_t
+    mbedtls_test_driver_aead_hooks_init( void )
 {
-    const test_driver_aead_hooks_t v = TEST_DRIVER_AEAD_INIT;
+    const mbedtls_test_driver_aead_hooks_t v = MBEDTLS_TEST_DRIVER_AEAD_INIT;
     return( v );
 }
 
-extern test_driver_aead_hooks_t test_driver_aead_hooks;
+extern mbedtls_test_driver_aead_hooks_t mbedtls_test_driver_aead_hooks;
 
-psa_status_t test_transparent_aead_encrypt(
+psa_status_t mbedtls_test_transparent_aead_encrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key_buffer, size_t key_buffer_size,
     psa_algorithm_t alg,
@@ -57,7 +58,7 @@
     const uint8_t *plaintext, size_t plaintext_length,
     uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length );
 
-psa_status_t test_transparent_aead_decrypt(
+psa_status_t mbedtls_test_transparent_aead_decrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key_buffer, size_t key_buffer_size,
     psa_algorithm_t alg,
diff --git a/tests/include/test/drivers/cipher.h b/tests/include/test/drivers/cipher.h
index 6d6a6af..4fe5596 100644
--- a/tests/include/test/drivers/cipher.h
+++ b/tests/include/test/drivers/cipher.h
@@ -41,101 +41,102 @@
     psa_status_t forced_status;
     /* Count the amount of times one of the cipher driver functions is called. */
     unsigned long hits;
-} test_driver_cipher_hooks_t;
+} mbedtls_test_driver_cipher_hooks_t;
 
-#define TEST_DRIVER_CIPHER_INIT { NULL, 0, PSA_SUCCESS, 0 }
-static inline test_driver_cipher_hooks_t test_driver_cipher_hooks_init( void )
+#define MBEDTLS_TEST_DRIVER_CIPHER_INIT { NULL, 0, PSA_SUCCESS, 0 }
+static inline mbedtls_test_driver_cipher_hooks_t
+     mbedtls_test_driver_cipher_hooks_init( void )
 {
-    const test_driver_cipher_hooks_t v = TEST_DRIVER_CIPHER_INIT;
+    const mbedtls_test_driver_cipher_hooks_t v = MBEDTLS_TEST_DRIVER_CIPHER_INIT;
     return( v );
 }
 
-extern test_driver_cipher_hooks_t test_driver_cipher_hooks;
+extern mbedtls_test_driver_cipher_hooks_t mbedtls_test_driver_cipher_hooks;
 
-psa_status_t test_transparent_cipher_encrypt(
+psa_status_t mbedtls_test_transparent_cipher_encrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
     const uint8_t *input, size_t input_length,
     uint8_t *output, size_t output_size, size_t *output_length);
 
-psa_status_t test_transparent_cipher_decrypt(
+psa_status_t mbedtls_test_transparent_cipher_decrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
     const uint8_t *input, size_t input_length,
     uint8_t *output, size_t output_size, size_t *output_length);
 
-psa_status_t test_transparent_cipher_encrypt_setup(
+psa_status_t mbedtls_test_transparent_cipher_encrypt_setup(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg);
 
-psa_status_t test_transparent_cipher_decrypt_setup(
+psa_status_t mbedtls_test_transparent_cipher_decrypt_setup(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg);
 
-psa_status_t test_transparent_cipher_abort(
+psa_status_t mbedtls_test_transparent_cipher_abort(
     mbedtls_transparent_test_driver_cipher_operation_t *operation );
 
-psa_status_t test_transparent_cipher_set_iv(
+psa_status_t mbedtls_test_transparent_cipher_set_iv(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const uint8_t *iv, size_t iv_length);
 
-psa_status_t test_transparent_cipher_update(
+psa_status_t mbedtls_test_transparent_cipher_update(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const uint8_t *input, size_t input_length,
     uint8_t *output, size_t output_size, size_t *output_length);
 
-psa_status_t test_transparent_cipher_finish(
+psa_status_t mbedtls_test_transparent_cipher_finish(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     uint8_t *output, size_t output_size, size_t *output_length);
 
 /*
  * opaque versions
  */
-psa_status_t test_opaque_cipher_encrypt(
+psa_status_t mbedtls_test_opaque_cipher_encrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
     const uint8_t *input, size_t input_length,
     uint8_t *output, size_t output_size, size_t *output_length);
 
-psa_status_t test_opaque_cipher_decrypt(
+psa_status_t mbedtls_test_opaque_cipher_decrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
     const uint8_t *input, size_t input_length,
     uint8_t *output, size_t output_size, size_t *output_length);
 
-psa_status_t test_opaque_cipher_encrypt_setup(
+psa_status_t mbedtls_test_opaque_cipher_encrypt_setup(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg);
 
-psa_status_t test_opaque_cipher_decrypt_setup(
+psa_status_t mbedtls_test_opaque_cipher_decrypt_setup(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg);
 
-psa_status_t test_opaque_cipher_abort(
+psa_status_t mbedtls_test_opaque_cipher_abort(
     mbedtls_opaque_test_driver_cipher_operation_t *operation);
 
-psa_status_t test_opaque_cipher_set_iv(
+psa_status_t mbedtls_test_opaque_cipher_set_iv(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const uint8_t *iv, size_t iv_length);
 
-psa_status_t test_opaque_cipher_update(
+psa_status_t mbedtls_test_opaque_cipher_update(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const uint8_t *input, size_t input_length,
     uint8_t *output, size_t output_size, size_t *output_length);
 
-psa_status_t test_opaque_cipher_finish(
+psa_status_t mbedtls_test_opaque_cipher_finish(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     uint8_t *output, size_t output_size, size_t *output_length);
 
diff --git a/tests/include/test/drivers/hash.h b/tests/include/test/drivers/hash.h
index 7be3689..ebe83de 100644
--- a/tests/include/test/drivers/hash.h
+++ b/tests/include/test/drivers/hash.h
@@ -37,42 +37,43 @@
     unsigned long hits;
     /* Status returned by the last hash driver entry point call. */
     psa_status_t driver_status;
-} test_driver_hash_hooks_t;
+} mbedtls_test_driver_hash_hooks_t;
 
-#define TEST_DRIVER_HASH_INIT { 0, 0, 0 }
-static inline test_driver_hash_hooks_t test_driver_hash_hooks_init( void )
+#define MBEDTLS_TEST_DRIVER_HASH_INIT { 0, 0, 0 }
+static inline mbedtls_test_driver_hash_hooks_t
+    mbedtls_test_driver_hash_hooks_init( void )
 {
-    const test_driver_hash_hooks_t v = TEST_DRIVER_HASH_INIT;
+    const mbedtls_test_driver_hash_hooks_t v = MBEDTLS_TEST_DRIVER_HASH_INIT;
     return( v );
 }
 
-extern test_driver_hash_hooks_t test_driver_hash_hooks;
+extern mbedtls_test_driver_hash_hooks_t mbedtls_test_driver_hash_hooks;
 
-psa_status_t test_transparent_hash_compute(
+psa_status_t mbedtls_test_transparent_hash_compute(
     psa_algorithm_t alg,
     const uint8_t *input, size_t input_length,
     uint8_t *hash, size_t hash_size, size_t *hash_length );
 
-psa_status_t test_transparent_hash_setup(
+psa_status_t mbedtls_test_transparent_hash_setup(
     mbedtls_transparent_test_driver_hash_operation_t *operation,
     psa_algorithm_t alg );
 
-psa_status_t test_transparent_hash_clone(
+psa_status_t mbedtls_test_transparent_hash_clone(
     const mbedtls_transparent_test_driver_hash_operation_t *source_operation,
     mbedtls_transparent_test_driver_hash_operation_t *target_operation );
 
-psa_status_t test_transparent_hash_update(
+psa_status_t mbedtls_test_transparent_hash_update(
     mbedtls_transparent_test_driver_hash_operation_t *operation,
     const uint8_t *input,
     size_t input_length );
 
-psa_status_t test_transparent_hash_finish(
+psa_status_t mbedtls_test_transparent_hash_finish(
     mbedtls_transparent_test_driver_hash_operation_t *operation,
     uint8_t *hash,
     size_t hash_size,
     size_t *hash_length );
 
-psa_status_t test_transparent_hash_abort(
+psa_status_t mbedtls_test_transparent_hash_abort(
     mbedtls_psa_hash_operation_t *operation );
 
 #endif /* PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/include/test/drivers/key_management.h b/tests/include/test/drivers/key_management.h
index 100fc18..45814fd 100644
--- a/tests/include/test/drivers/key_management.h
+++ b/tests/include/test/drivers/key_management.h
@@ -42,41 +42,44 @@
     /* Count the amount of times one of the key management driver functions
      * is called. */
     unsigned long hits;
-} test_driver_key_management_hooks_t;
+} mbedtls_test_driver_key_management_hooks_t;
 
-#define TEST_DRIVER_KEY_MANAGEMENT_INIT { NULL, 0, PSA_SUCCESS, 0 }
-static inline test_driver_key_management_hooks_t test_driver_key_management_hooks_init( void )
+#define MBEDTLS_TEST_DRIVER_KEY_MANAGEMENT_INIT { NULL, 0, PSA_SUCCESS, 0 }
+static inline mbedtls_test_driver_key_management_hooks_t
+    mbedtls_test_driver_key_management_hooks_init( void )
 {
-    const test_driver_key_management_hooks_t v = TEST_DRIVER_KEY_MANAGEMENT_INIT;
+    const mbedtls_test_driver_key_management_hooks_t
+        v = MBEDTLS_TEST_DRIVER_KEY_MANAGEMENT_INIT;
     return( v );
 }
 
-extern test_driver_key_management_hooks_t test_driver_key_management_hooks;
+extern mbedtls_test_driver_key_management_hooks_t
+    mbedtls_test_driver_key_management_hooks;
 
-psa_status_t test_transparent_generate_key(
+psa_status_t mbedtls_test_transparent_generate_key(
     const psa_key_attributes_t *attributes,
     uint8_t *key, size_t key_size, size_t *key_length );
 
-psa_status_t test_opaque_generate_key(
+psa_status_t mbedtls_test_opaque_generate_key(
     const psa_key_attributes_t *attributes,
     uint8_t *key, size_t key_size, size_t *key_length );
 
-psa_status_t test_opaque_export_key(
+psa_status_t mbedtls_test_opaque_export_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     uint8_t *data, size_t data_size, size_t *data_length );
 
-psa_status_t test_transparent_export_public_key(
+psa_status_t mbedtls_test_transparent_export_public_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     uint8_t *data, size_t data_size, size_t *data_length );
 
-psa_status_t test_opaque_export_public_key(
+psa_status_t mbedtls_test_opaque_export_public_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     uint8_t *data, size_t data_size, size_t *data_length );
 
-psa_status_t test_transparent_import_key(
+psa_status_t mbedtls_test_transparent_import_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *data,
     size_t data_length,
@@ -85,7 +88,7 @@
     size_t *key_buffer_length,
     size_t *bits);
 
-psa_status_t test_opaque_get_builtin_key(
+psa_status_t mbedtls_test_opaque_get_builtin_key(
     psa_drv_slot_number_t slot_number,
     psa_key_attributes_t *attributes,
     uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length );
diff --git a/tests/include/test/drivers/test_driver.h b/tests/include/test/drivers/mbedtls_test_driver.h
similarity index 100%
rename from tests/include/test/drivers/test_driver.h
rename to tests/include/test/drivers/mbedtls_test_driver.h
diff --git a/tests/include/test/drivers/signature.h b/tests/include/test/drivers/signature.h
index e785151..1586ce9 100644
--- a/tests/include/test/drivers/signature.h
+++ b/tests/include/test/drivers/signature.h
@@ -38,40 +38,44 @@
     psa_status_t forced_status;
     /* Count the amount of times one of the signature driver functions is called. */
     unsigned long hits;
-} test_driver_signature_hooks_t;
+} mbedtls_test_driver_signature_hooks_t;
 
-#define TEST_DRIVER_SIGNATURE_INIT { NULL, 0, PSA_SUCCESS, 0 }
-static inline test_driver_signature_hooks_t test_driver_signature_hooks_init( void )
+#define MBEDTLS_TEST_DRIVER_SIGNATURE_INIT { NULL, 0, PSA_SUCCESS, 0 }
+static inline mbedtls_test_driver_signature_hooks_t
+    mbedtls_test_driver_signature_hooks_init( void )
 {
-    const test_driver_signature_hooks_t v = TEST_DRIVER_SIGNATURE_INIT;
+    const mbedtls_test_driver_signature_hooks_t
+        v = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
     return( v );
 }
 
-extern test_driver_signature_hooks_t test_driver_signature_sign_hooks;
-extern test_driver_signature_hooks_t test_driver_signature_verify_hooks;
+extern mbedtls_test_driver_signature_hooks_t
+    mbedtls_test_driver_signature_sign_hooks;
+extern mbedtls_test_driver_signature_hooks_t
+    mbedtls_test_driver_signature_verify_hooks;
 
-psa_status_t test_transparent_signature_sign_hash(
+psa_status_t mbedtls_test_transparent_signature_sign_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
     const uint8_t *hash, size_t hash_length,
     uint8_t *signature, size_t signature_size, size_t *signature_length );
 
-psa_status_t test_opaque_signature_sign_hash(
+psa_status_t mbedtls_test_opaque_signature_sign_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
     const uint8_t *hash, size_t hash_length,
     uint8_t *signature, size_t signature_size, size_t *signature_length );
 
-psa_status_t test_transparent_signature_verify_hash(
+psa_status_t mbedtls_test_transparent_signature_verify_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
     const uint8_t *hash, size_t hash_length,
     const uint8_t *signature, size_t signature_length );
 
-psa_status_t test_opaque_signature_verify_hash(
+psa_status_t mbedtls_test_opaque_signature_verify_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
diff --git a/tests/include/test/drivers/size.h b/tests/include/test/drivers/size.h
index 4bfe986..577e17b 100644
--- a/tests/include/test/drivers/size.h
+++ b/tests/include/test/drivers/size.h
@@ -31,16 +31,17 @@
 
 typedef struct {
     unsigned int context;
-} test_driver_key_context_t;
+} mbedtls_test_driver_key_context_t;
 
-/** \def TEST_DRIVER_KEY_CONTEXT_BASE_SIZE
+/** \def MBEDTLS_TEST_DRIVER_KEY_CONTEXT_BASE_SIZE
  *
  * This macro returns the base size for the key context. It is the size of the
  * driver specific information stored in each key context.
  */
-#define TEST_DRIVER_KEY_CONTEXT_BASE_SIZE          sizeof( test_driver_key_context_t )
+#define MBEDTLS_TEST_DRIVER_KEY_CONTEXT_BASE_SIZE \
+    sizeof( mbedtls_test_driver_key_context_t )
 
-/** \def TEST_DRIVER_KEY_CONTEXT_KEY_PAIR_SIZE
+/** \def MBEDTLS_TEST_DRIVER_KEY_CONTEXT_KEY_PAIR_SIZE
  *
  * Number of bytes included in every key context for a key pair.
  *
@@ -49,47 +50,47 @@
  * subtracting the public key size below from this one.
  */
 
-#define TEST_DRIVER_KEY_CONTEXT_KEY_PAIR_SIZE      65
+#define MBEDTLS_TEST_DRIVER_KEY_CONTEXT_KEY_PAIR_SIZE      65
 
-/** \def TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE
+/** \def MBEDTLS_TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE
  *
  * Number of bytes included in every key context for a public key.
  *
  * For ECC public keys, it needs 257 bits so 33 bytes.
  */
-#define TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE    33
+#define MBEDTLS_TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE    33
 
-/** \def TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR
+/** \def MBEDTLS_TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR
  *
  * Every key context for a symmetric key includes this many times the key size.
  */
-#define TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR   0
+#define MBEDTLS_TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR   0
 
-/** \def TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY
+/** \def MBEDTLS_TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY
  *
  * If this is true for a key pair, the key context includes space for the public key.
  * If this is false, no additional space is added for the public key.
  *
  * For this instance, store the public key with the private one.
  */
-#define TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY   1
+#define MBEDTLS_TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY   1
 
-/** \def TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION
+/** \def MBEDTLS_TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION
  *
- * If TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION is defined, the test driver
+ * If MBEDTLS_TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION is defined, the test driver
  * provides a size_function entry point, otherwise, it does not.
  *
  * Some opaque drivers have the need to support a custom size for the storage
  * of key and context information. The size_function provides the ability to
  * provide that customization.
  */
-//#define TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION
+//#define MBEDTLS_TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION
 
-#ifdef TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION
-size_t test_size_function(
+#ifdef MBEDTLS_TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION
+size_t mbedtls_test_size_function(
     const psa_key_type_t key_type,
     const size_t key_bits );
-#endif /* TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION */
+#endif /* MBEDTLS_TEST_DRIVER_KEY_CONTEXT_SIZE_FUNCTION */
 
 #endif /* PSA_CRYPTO_DRIVER_TEST */
 #endif /* PSA_CRYPTO_TEST_DRIVERS_SIZE_H */
diff --git a/tests/scripts/list-macros.sh b/tests/scripts/list-macros.sh
index a8617a0..8ed9571 100755
--- a/tests/scripts/list-macros.sh
+++ b/tests/scripts/list-macros.sh
@@ -22,7 +22,7 @@
     exit 1
 fi
 
-HEADERS=$( ls include/mbedtls/*.h include/psa/*.h | egrep -v 'compat-1\.3\.h' )
+HEADERS=$( ls include/mbedtls/*.h include/psa/*.h tests/include/test/drivers/*.h | egrep -v 'compat-1\.3\.h' )
 HEADERS="$HEADERS library/*.h"
 HEADERS="$HEADERS 3rdparty/everest/include/everest/everest.h 3rdparty/everest/include/everest/x25519.h"
 
diff --git a/tests/src/drivers/hash.c b/tests/src/drivers/hash.c
index d69a127..f95aa6b 100644
--- a/tests/src/drivers/hash.c
+++ b/tests/src/drivers/hash.c
@@ -28,133 +28,134 @@
 
 #include "test/drivers/hash.h"
 
-test_driver_hash_hooks_t test_driver_hash_hooks = TEST_DRIVER_HASH_INIT;
+mbedtls_test_driver_hash_hooks_t
+    mbedtls_test_driver_hash_hooks = MBEDTLS_TEST_DRIVER_HASH_INIT;
 
-psa_status_t test_transparent_hash_compute(
+psa_status_t mbedtls_test_transparent_hash_compute(
     psa_algorithm_t alg,
     const uint8_t *input, size_t input_length,
     uint8_t *hash, size_t hash_size, size_t *hash_length )
 {
-    test_driver_hash_hooks.hits++;
+    mbedtls_test_driver_hash_hooks.hits++;
 
-    if( test_driver_hash_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_hash_hooks.driver_status =
-             test_driver_hash_hooks.forced_status;
+         mbedtls_test_driver_hash_hooks.driver_status =
+             mbedtls_test_driver_hash_hooks.forced_status;
     }
     else
     {
-        test_driver_hash_hooks.driver_status =
+        mbedtls_test_driver_hash_hooks.driver_status =
             mbedtls_transparent_test_driver_hash_compute(
                 alg, input, input_length,
                 hash, hash_size, hash_length );
     }
 
-    return( test_driver_hash_hooks.driver_status );
+    return( mbedtls_test_driver_hash_hooks.driver_status );
 }
 
-psa_status_t test_transparent_hash_setup(
+psa_status_t mbedtls_test_transparent_hash_setup(
     mbedtls_transparent_test_driver_hash_operation_t *operation,
     psa_algorithm_t alg )
 {
-    test_driver_hash_hooks.hits++;
+    mbedtls_test_driver_hash_hooks.hits++;
 
-    if( test_driver_hash_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_hash_hooks.driver_status =
-             test_driver_hash_hooks.forced_status;
+         mbedtls_test_driver_hash_hooks.driver_status =
+             mbedtls_test_driver_hash_hooks.forced_status;
     }
     else
     {
-        test_driver_hash_hooks.driver_status =
+        mbedtls_test_driver_hash_hooks.driver_status =
             mbedtls_transparent_test_driver_hash_setup( operation, alg );
     }
 
-    return( test_driver_hash_hooks.driver_status );
+    return( mbedtls_test_driver_hash_hooks.driver_status );
 }
 
-psa_status_t test_transparent_hash_clone(
+psa_status_t mbedtls_test_transparent_hash_clone(
     const mbedtls_transparent_test_driver_hash_operation_t *source_operation,
     mbedtls_transparent_test_driver_hash_operation_t *target_operation )
 {
-    test_driver_hash_hooks.hits++;
+    mbedtls_test_driver_hash_hooks.hits++;
 
-    if( test_driver_hash_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_hash_hooks.driver_status =
-             test_driver_hash_hooks.forced_status;
+         mbedtls_test_driver_hash_hooks.driver_status =
+             mbedtls_test_driver_hash_hooks.forced_status;
     }
     else
     {
-        test_driver_hash_hooks.driver_status =
+        mbedtls_test_driver_hash_hooks.driver_status =
             mbedtls_transparent_test_driver_hash_clone( source_operation,
                                                         target_operation );
     }
 
-    return( test_driver_hash_hooks.driver_status );
+    return( mbedtls_test_driver_hash_hooks.driver_status );
 }
 
-psa_status_t test_transparent_hash_update(
+psa_status_t mbedtls_test_transparent_hash_update(
     mbedtls_transparent_test_driver_hash_operation_t *operation,
     const uint8_t *input,
     size_t input_length )
 {
-    test_driver_hash_hooks.hits++;
+    mbedtls_test_driver_hash_hooks.hits++;
 
-    if( test_driver_hash_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_hash_hooks.driver_status =
-             test_driver_hash_hooks.forced_status;
+         mbedtls_test_driver_hash_hooks.driver_status =
+             mbedtls_test_driver_hash_hooks.forced_status;
     }
     else
     {
-        test_driver_hash_hooks.driver_status =
+        mbedtls_test_driver_hash_hooks.driver_status =
             mbedtls_transparent_test_driver_hash_update(
                 operation, input, input_length );
     }
 
-    return( test_driver_hash_hooks.driver_status );
+    return( mbedtls_test_driver_hash_hooks.driver_status );
 }
 
-psa_status_t test_transparent_hash_finish(
+psa_status_t mbedtls_test_transparent_hash_finish(
     mbedtls_transparent_test_driver_hash_operation_t *operation,
     uint8_t *hash,
     size_t hash_size,
     size_t *hash_length )
 {
-    test_driver_hash_hooks.hits++;
+    mbedtls_test_driver_hash_hooks.hits++;
 
-    if( test_driver_hash_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_hash_hooks.driver_status =
-             test_driver_hash_hooks.forced_status;
+         mbedtls_test_driver_hash_hooks.driver_status =
+             mbedtls_test_driver_hash_hooks.forced_status;
     }
     else
     {
-        test_driver_hash_hooks.driver_status =
+        mbedtls_test_driver_hash_hooks.driver_status =
             mbedtls_transparent_test_driver_hash_finish(
                 operation, hash, hash_size, hash_length );
     }
 
-    return( test_driver_hash_hooks.driver_status );
+    return( mbedtls_test_driver_hash_hooks.driver_status );
 }
 
-psa_status_t test_transparent_hash_abort(
+psa_status_t mbedtls_test_transparent_hash_abort(
     mbedtls_transparent_test_driver_hash_operation_t *operation )
 {
-    test_driver_hash_hooks.hits++;
+    mbedtls_test_driver_hash_hooks.hits++;
 
-    if( test_driver_hash_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_hash_hooks.driver_status =
-             test_driver_hash_hooks.forced_status;
+         mbedtls_test_driver_hash_hooks.driver_status =
+             mbedtls_test_driver_hash_hooks.forced_status;
     }
     else
     {
-        test_driver_hash_hooks.driver_status =
+        mbedtls_test_driver_hash_hooks.driver_status =
             mbedtls_transparent_test_driver_hash_abort( operation );
     }
 
-    return( test_driver_hash_hooks.driver_status );
+    return( mbedtls_test_driver_hash_hooks.driver_status );
 }
 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/platform_builtin_keys.c b/tests/src/drivers/platform_builtin_keys.c
index 759fa78..57d040a 100644
--- a/tests/src/drivers/platform_builtin_keys.c
+++ b/tests/src/drivers/platform_builtin_keys.c
@@ -24,7 +24,7 @@
 #include <psa/crypto_extra.h>
 
 #if defined(PSA_CRYPTO_DRIVER_TEST)
-#include <test/drivers/test_driver.h>
+#include <test/drivers/mbedtls_test_driver.h>
 #endif
 
 typedef struct
diff --git a/tests/src/drivers/test_driver_aead.c b/tests/src/drivers/test_driver_aead.c
index c877525..25396c9 100644
--- a/tests/src/drivers/test_driver_aead.c
+++ b/tests/src/drivers/test_driver_aead.c
@@ -28,9 +28,10 @@
 
 #include "test/drivers/aead.h"
 
-test_driver_aead_hooks_t test_driver_aead_hooks = TEST_DRIVER_AEAD_INIT;
+mbedtls_test_driver_aead_hooks_t
+    mbedtls_test_driver_aead_hooks = MBEDTLS_TEST_DRIVER_AEAD_INIT;
 
-psa_status_t test_transparent_aead_encrypt(
+psa_status_t mbedtls_test_transparent_aead_encrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key_buffer, size_t key_buffer_size,
     psa_algorithm_t alg,
@@ -39,16 +40,16 @@
     const uint8_t *plaintext, size_t plaintext_length,
     uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length )
 {
-    test_driver_aead_hooks.hits++;
+    mbedtls_test_driver_aead_hooks.hits++;
 
-    if( test_driver_aead_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_aead_hooks.driver_status =
-             test_driver_aead_hooks.forced_status;
+         mbedtls_test_driver_aead_hooks.driver_status =
+             mbedtls_test_driver_aead_hooks.forced_status;
     }
     else
     {
-        test_driver_aead_hooks.driver_status =
+        mbedtls_test_driver_aead_hooks.driver_status =
             mbedtls_psa_aead_encrypt(
                 attributes, key_buffer, key_buffer_size,
                 alg,
@@ -58,10 +59,10 @@
                 ciphertext, ciphertext_size, ciphertext_length );
     }
 
-    return( test_driver_aead_hooks.driver_status );
+    return( mbedtls_test_driver_aead_hooks.driver_status );
 }
 
-psa_status_t test_transparent_aead_decrypt(
+psa_status_t mbedtls_test_transparent_aead_decrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key_buffer, size_t key_buffer_size,
     psa_algorithm_t alg,
@@ -70,16 +71,16 @@
     const uint8_t *ciphertext, size_t ciphertext_length,
     uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length )
 {
-    test_driver_aead_hooks.hits++;
+    mbedtls_test_driver_aead_hooks.hits++;
 
-    if( test_driver_aead_hooks.forced_status != PSA_SUCCESS )
+    if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
     {
-         test_driver_aead_hooks.driver_status =
-             test_driver_aead_hooks.forced_status;
+         mbedtls_test_driver_aead_hooks.driver_status =
+             mbedtls_test_driver_aead_hooks.forced_status;
     }
     else
     {
-        test_driver_aead_hooks.driver_status =
+        mbedtls_test_driver_aead_hooks.driver_status =
             mbedtls_psa_aead_decrypt(
                 attributes, key_buffer, key_buffer_size,
                 alg,
@@ -89,7 +90,7 @@
                 plaintext, plaintext_size, plaintext_length );
     }
 
-    return( test_driver_aead_hooks.driver_status );
+    return( mbedtls_test_driver_aead_hooks.driver_status );
 }
 
 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_cipher.c b/tests/src/drivers/test_driver_cipher.c
index e241ba4..a415dd8 100644
--- a/tests/src/drivers/test_driver_cipher.c
+++ b/tests/src/drivers/test_driver_cipher.c
@@ -36,9 +36,10 @@
 
 #include <string.h>
 
-test_driver_cipher_hooks_t test_driver_cipher_hooks = TEST_DRIVER_CIPHER_INIT;
+mbedtls_test_driver_cipher_hooks_t mbedtls_test_driver_cipher_hooks =
+    MBEDTLS_TEST_DRIVER_CIPHER_INIT;
 
-static psa_status_t test_transparent_cipher_oneshot(
+static psa_status_t mbedtls_test_transparent_cipher_oneshot(
     mbedtls_operation_t direction,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
@@ -46,7 +47,7 @@
     const uint8_t *input, size_t input_length,
     uint8_t *output, size_t output_size, size_t *output_length)
 {
-    test_driver_cipher_hooks.hits++;
+    mbedtls_test_driver_cipher_hooks.hits++;
 
     /* Test driver supports AES-CTR only, to verify operation calls. */
     if( alg != PSA_ALG_CTR ||
@@ -54,21 +55,21 @@
         return( PSA_ERROR_NOT_SUPPORTED );
 
     /* If test driver response code is not SUCCESS, we can return early */
-    if( test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_cipher_hooks.forced_status );
+    if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
 
     /* If test driver output is overridden, we don't need to do actual crypto */
-    if( test_driver_cipher_hooks.forced_output != NULL )
+    if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
     {
-        if( output_size < test_driver_cipher_hooks.forced_output_length )
+        if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
             return( PSA_ERROR_BUFFER_TOO_SMALL );
 
         memcpy( output,
-                test_driver_cipher_hooks.forced_output,
-                test_driver_cipher_hooks.forced_output_length );
-        *output_length = test_driver_cipher_hooks.forced_output_length;
+                mbedtls_test_driver_cipher_hooks.forced_output,
+                mbedtls_test_driver_cipher_hooks.forced_output_length );
+        *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
 
-        return( test_driver_cipher_hooks.forced_status );
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
     }
 
     /* Run AES-CTR using the cipher module */
@@ -166,7 +167,7 @@
     }
 }
 
-psa_status_t test_transparent_cipher_encrypt(
+psa_status_t mbedtls_test_transparent_cipher_encrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
@@ -174,7 +175,7 @@
     uint8_t *output, size_t output_size, size_t *output_length)
 {
     return (
-        test_transparent_cipher_oneshot(
+        mbedtls_test_transparent_cipher_oneshot(
             MBEDTLS_ENCRYPT,
             attributes,
             key, key_length,
@@ -183,7 +184,7 @@
             output, output_size, output_length) );
 }
 
-psa_status_t test_transparent_cipher_decrypt(
+psa_status_t mbedtls_test_transparent_cipher_decrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
@@ -191,7 +192,7 @@
     uint8_t *output, size_t output_size, size_t *output_length)
 {
     return (
-        test_transparent_cipher_oneshot(
+        mbedtls_test_transparent_cipher_oneshot(
             MBEDTLS_DECRYPT,
             attributes,
             key, key_length,
@@ -200,13 +201,13 @@
             output, output_size, output_length) );
 }
 
-psa_status_t test_transparent_cipher_encrypt_setup(
+psa_status_t mbedtls_test_transparent_cipher_encrypt_setup(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg)
 {
-    test_driver_cipher_hooks.hits++;
+    mbedtls_test_driver_cipher_hooks.hits++;
 
     /* Wiping the entire struct here, instead of member-by-member. This is
      * useful for the test suite, since it gives a chance of catching memory
@@ -214,32 +215,32 @@
      * our context struct. */
     memset( operation, 0, sizeof( *operation ) );
 
-    if( test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_cipher_hooks.forced_status );
+    if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
 
     return ( mbedtls_transparent_test_driver_cipher_encrypt_setup(
                  operation, attributes, key, key_length, alg ) );
 }
 
-psa_status_t test_transparent_cipher_decrypt_setup(
+psa_status_t mbedtls_test_transparent_cipher_decrypt_setup(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg)
 {
-    test_driver_cipher_hooks.hits++;
+    mbedtls_test_driver_cipher_hooks.hits++;
 
-    if( test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_cipher_hooks.forced_status );
+    if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
 
     return ( mbedtls_transparent_test_driver_cipher_decrypt_setup(
                  operation, attributes, key, key_length, alg ) );
 }
 
-psa_status_t test_transparent_cipher_abort(
+psa_status_t mbedtls_test_transparent_cipher_abort(
     mbedtls_transparent_test_driver_cipher_operation_t *operation)
 {
-    test_driver_cipher_hooks.hits++;
+    mbedtls_test_driver_cipher_hooks.hits++;
 
     if( operation->alg == 0 )
         return( PSA_SUCCESS );
@@ -252,24 +253,24 @@
      * our context struct. */
     memset( operation, 0, sizeof( *operation ) );
 
-    return( test_driver_cipher_hooks.forced_status );
+    return( mbedtls_test_driver_cipher_hooks.forced_status );
 }
 
-psa_status_t test_transparent_cipher_set_iv(
+psa_status_t mbedtls_test_transparent_cipher_set_iv(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const uint8_t *iv,
     size_t iv_length)
 {
-    test_driver_cipher_hooks.hits++;
+    mbedtls_test_driver_cipher_hooks.hits++;
 
-    if( test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_cipher_hooks.forced_status );
+    if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
 
     return( mbedtls_transparent_test_driver_cipher_set_iv(
                 operation, iv, iv_length ) );
 }
 
-psa_status_t test_transparent_cipher_update(
+psa_status_t mbedtls_test_transparent_cipher_update(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     const uint8_t *input,
     size_t input_length,
@@ -277,52 +278,52 @@
     size_t output_size,
     size_t *output_length)
 {
-    test_driver_cipher_hooks.hits++;
+    mbedtls_test_driver_cipher_hooks.hits++;
 
-    if( test_driver_cipher_hooks.forced_output != NULL )
+    if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
     {
-        if( output_size < test_driver_cipher_hooks.forced_output_length )
+        if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
             return PSA_ERROR_BUFFER_TOO_SMALL;
 
         memcpy( output,
-                test_driver_cipher_hooks.forced_output,
-                test_driver_cipher_hooks.forced_output_length );
-        *output_length = test_driver_cipher_hooks.forced_output_length;
+                mbedtls_test_driver_cipher_hooks.forced_output,
+                mbedtls_test_driver_cipher_hooks.forced_output_length );
+        *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
 
-        return( test_driver_cipher_hooks.forced_status );
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
     }
 
-    if( test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_cipher_hooks.forced_status );
+    if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
 
     return( mbedtls_transparent_test_driver_cipher_update(
                 operation, input, input_length,
                 output, output_size, output_length ) );
 }
 
-psa_status_t test_transparent_cipher_finish(
+psa_status_t mbedtls_test_transparent_cipher_finish(
     mbedtls_transparent_test_driver_cipher_operation_t *operation,
     uint8_t *output,
     size_t output_size,
     size_t *output_length)
 {
-    test_driver_cipher_hooks.hits++;
+    mbedtls_test_driver_cipher_hooks.hits++;
 
-    if( test_driver_cipher_hooks.forced_output != NULL )
+    if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
     {
-        if( output_size < test_driver_cipher_hooks.forced_output_length )
+        if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
             return PSA_ERROR_BUFFER_TOO_SMALL;
 
         memcpy( output,
-                test_driver_cipher_hooks.forced_output,
-                test_driver_cipher_hooks.forced_output_length );
-        *output_length = test_driver_cipher_hooks.forced_output_length;
+                mbedtls_test_driver_cipher_hooks.forced_output,
+                mbedtls_test_driver_cipher_hooks.forced_output_length );
+        *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
 
-        return( test_driver_cipher_hooks.forced_status );
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
     }
 
-    if( test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_cipher_hooks.forced_status );
+    if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_cipher_hooks.forced_status );
 
     return( mbedtls_transparent_test_driver_cipher_finish(
                 operation, output, output_size, output_length ) );
@@ -331,7 +332,7 @@
 /*
  * opaque versions, to do
  */
-psa_status_t test_opaque_cipher_encrypt(
+psa_status_t mbedtls_test_opaque_cipher_encrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
@@ -350,7 +351,7 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_opaque_cipher_decrypt(
+psa_status_t mbedtls_test_opaque_cipher_decrypt(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
@@ -369,7 +370,7 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_opaque_cipher_encrypt_setup(
+psa_status_t mbedtls_test_opaque_cipher_encrypt_setup(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
@@ -383,7 +384,7 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_opaque_cipher_decrypt_setup(
+psa_status_t mbedtls_test_opaque_cipher_decrypt_setup(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
@@ -397,14 +398,14 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_opaque_cipher_abort(
+psa_status_t mbedtls_test_opaque_cipher_abort(
     mbedtls_opaque_test_driver_cipher_operation_t *operation )
 {
     (void) operation;
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_opaque_cipher_set_iv(
+psa_status_t mbedtls_test_opaque_cipher_set_iv(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const uint8_t *iv,
     size_t iv_length)
@@ -415,7 +416,7 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_opaque_cipher_update(
+psa_status_t mbedtls_test_opaque_cipher_update(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     const uint8_t *input,
     size_t input_length,
@@ -432,7 +433,7 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_opaque_cipher_finish(
+psa_status_t mbedtls_test_opaque_cipher_finish(
     mbedtls_opaque_test_driver_cipher_operation_t *operation,
     uint8_t *output,
     size_t output_size,
diff --git a/tests/src/drivers/test_driver_key_management.c b/tests/src/drivers/test_driver_key_management.c
index a0626fb..19e1033 100644
--- a/tests/src/drivers/test_driver_key_management.c
+++ b/tests/src/drivers/test_driver_key_management.c
@@ -38,18 +38,18 @@
 
 #include <string.h>
 
-test_driver_key_management_hooks_t test_driver_key_management_hooks =
-    TEST_DRIVER_KEY_MANAGEMENT_INIT;
+mbedtls_test_driver_key_management_hooks_t
+    mbedtls_test_driver_key_management_hooks = MBEDTLS_TEST_DRIVER_KEY_MANAGEMENT_INIT;
 
-const uint8_t test_driver_aes_key[16] =
+const uint8_t mbedtls_test_driver_aes_key[16] =
     { 0x36, 0x77, 0x39, 0x7A, 0x24, 0x43, 0x26, 0x46,
       0x29, 0x4A, 0x40, 0x4E, 0x63, 0x52, 0x66, 0x55 };
-const uint8_t test_driver_ecdsa_key[32] =
+const uint8_t mbedtls_test_driver_ecdsa_key[32] =
     { 0xdc, 0x7d, 0x9d, 0x26, 0xd6, 0x7a, 0x4f, 0x63,
       0x2c, 0x34, 0xc2, 0xdc, 0x0b, 0x69, 0x86, 0x18,
       0x38, 0x82, 0xc2, 0x06, 0xdf, 0x04, 0xcd, 0xb7,
       0xd6, 0x9a, 0xab, 0xe2, 0x8b, 0xe4, 0xf8, 0x1a };
-const uint8_t test_driver_ecdsa_pubkey[65] =
+const uint8_t mbedtls_test_driver_ecdsa_pubkey[65] =
     { 0x04,
       0x85, 0xf6, 0x4d, 0x89, 0xf0, 0x0b, 0xe6, 0x6c,
       0x88, 0xdd, 0x93, 0x7e, 0xfd, 0x6d, 0x7c, 0x44,
@@ -60,22 +60,23 @@
       0xbc, 0x25, 0x16, 0xc3, 0xd2, 0x70, 0x2d, 0x79,
       0x2f, 0x13, 0x1a, 0x92, 0x20, 0x95, 0xfd, 0x6c };
 
-psa_status_t test_transparent_generate_key(
+psa_status_t mbedtls_test_transparent_generate_key(
     const psa_key_attributes_t *attributes,
     uint8_t *key, size_t key_size, size_t *key_length )
 {
-    ++test_driver_key_management_hooks.hits;
+    ++mbedtls_test_driver_key_management_hooks.hits;
 
-    if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_key_management_hooks.forced_status );
+    if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_key_management_hooks.forced_status );
 
-    if( test_driver_key_management_hooks.forced_output != NULL )
+    if( mbedtls_test_driver_key_management_hooks.forced_output != NULL )
     {
-        if( test_driver_key_management_hooks.forced_output_length > key_size )
+        if( mbedtls_test_driver_key_management_hooks.forced_output_length >
+            key_size )
             return( PSA_ERROR_BUFFER_TOO_SMALL );
-        memcpy( key, test_driver_key_management_hooks.forced_output,
-                test_driver_key_management_hooks.forced_output_length );
-        *key_length = test_driver_key_management_hooks.forced_output_length;
+        memcpy( key, mbedtls_test_driver_key_management_hooks.forced_output,
+                mbedtls_test_driver_key_management_hooks.forced_output_length );
+        *key_length = mbedtls_test_driver_key_management_hooks.forced_output_length;
         return( PSA_SUCCESS );
     }
 
@@ -102,7 +103,7 @@
     }
 }
 
-psa_status_t test_opaque_generate_key(
+psa_status_t mbedtls_test_opaque_generate_key(
     const psa_key_attributes_t *attributes,
     uint8_t *key, size_t key_size, size_t *key_length )
 {
@@ -113,7 +114,7 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_transparent_import_key(
+psa_status_t mbedtls_test_transparent_import_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *data,
     size_t data_length,
@@ -122,10 +123,10 @@
     size_t *key_buffer_length,
     size_t *bits)
 {
-    ++test_driver_key_management_hooks.hits;
+    ++mbedtls_test_driver_key_management_hooks.hits;
 
-    if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_key_management_hooks.forced_status );
+    if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_key_management_hooks.forced_status );
 
     psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
     psa_key_type_t type = psa_get_key_type( attributes );
@@ -168,7 +169,7 @@
     return( status );
 }
 
-psa_status_t test_opaque_export_key(
+psa_status_t mbedtls_test_opaque_export_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     uint8_t *data, size_t data_size, size_t *data_length )
@@ -199,12 +200,12 @@
                   PSA_KEY_USAGE_EXPORT ) == 0 )
                 return( PSA_ERROR_CORRUPTION_DETECTED );
 
-            if( data_size < sizeof( test_driver_ecdsa_key ) )
+            if( data_size < sizeof( mbedtls_test_driver_ecdsa_key ) )
                 return( PSA_ERROR_BUFFER_TOO_SMALL );
 
-            memcpy( data, test_driver_ecdsa_key,
-                    sizeof( test_driver_ecdsa_key ) );
-            *data_length = sizeof( test_driver_ecdsa_key );
+            memcpy( data, mbedtls_test_driver_ecdsa_key,
+                    sizeof( mbedtls_test_driver_ecdsa_key ) );
+            *data_length = sizeof( mbedtls_test_driver_ecdsa_key );
             return( PSA_SUCCESS );
 
         case PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT:
@@ -220,12 +221,12 @@
                   PSA_KEY_USAGE_EXPORT ) == 0 )
                 return( PSA_ERROR_CORRUPTION_DETECTED );
 
-            if( data_size < sizeof( test_driver_aes_key ) )
+            if( data_size < sizeof( mbedtls_test_driver_aes_key ) )
                 return( PSA_ERROR_BUFFER_TOO_SMALL );
 
-            memcpy( data, test_driver_aes_key,
-                    sizeof( test_driver_aes_key ) );
-            *data_length = sizeof( test_driver_aes_key );
+            memcpy( data, mbedtls_test_driver_aes_key,
+                    sizeof( mbedtls_test_driver_aes_key ) );
+            *data_length = sizeof( mbedtls_test_driver_aes_key );
             return( PSA_SUCCESS );
 
         default:
@@ -233,23 +234,24 @@
     }
 }
 
-psa_status_t test_transparent_export_public_key(
+psa_status_t mbedtls_test_transparent_export_public_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *key_buffer, size_t key_buffer_size,
     uint8_t *data, size_t data_size, size_t *data_length )
 {
-    ++test_driver_key_management_hooks.hits;
+    ++mbedtls_test_driver_key_management_hooks.hits;
 
-    if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_key_management_hooks.forced_status );
+    if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_key_management_hooks.forced_status );
 
-    if( test_driver_key_management_hooks.forced_output != NULL )
+    if( mbedtls_test_driver_key_management_hooks.forced_output != NULL )
     {
-        if( test_driver_key_management_hooks.forced_output_length > data_size )
+        if( mbedtls_test_driver_key_management_hooks.forced_output_length >
+            data_size )
             return( PSA_ERROR_BUFFER_TOO_SMALL );
-        memcpy( data, test_driver_key_management_hooks.forced_output,
-                test_driver_key_management_hooks.forced_output_length );
-        *data_length = test_driver_key_management_hooks.forced_output_length;
+        memcpy( data, mbedtls_test_driver_key_management_hooks.forced_output,
+                mbedtls_test_driver_key_management_hooks.forced_output_length );
+        *data_length = mbedtls_test_driver_key_management_hooks.forced_output_length;
         return( PSA_SUCCESS );
     }
 
@@ -288,7 +290,7 @@
     return( status );
 }
 
-psa_status_t test_opaque_export_public_key(
+psa_status_t mbedtls_test_opaque_export_public_key(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     uint8_t *data, size_t data_size, size_t *data_length )
@@ -315,12 +317,12 @@
                 PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) )
                 return( PSA_ERROR_CORRUPTION_DETECTED );
 
-            if( data_size < sizeof( test_driver_ecdsa_pubkey ) )
+            if( data_size < sizeof( mbedtls_test_driver_ecdsa_pubkey ) )
                 return( PSA_ERROR_BUFFER_TOO_SMALL );
 
-            memcpy( data, test_driver_ecdsa_pubkey,
-                    sizeof( test_driver_ecdsa_pubkey ) );
-            *data_length = sizeof( test_driver_ecdsa_pubkey );
+            memcpy( data, mbedtls_test_driver_ecdsa_pubkey,
+                    sizeof( mbedtls_test_driver_ecdsa_pubkey ) );
+            *data_length = sizeof( mbedtls_test_driver_ecdsa_pubkey );
             return( PSA_SUCCESS );
 
         default:
@@ -338,7 +340,7 @@
  * (i.e. for an actual driver this would mean 'builtin_key_size' =
  * sizeof(psa_drv_slot_number_t)).
  */
-psa_status_t test_opaque_get_builtin_key(
+psa_status_t mbedtls_test_opaque_get_builtin_key(
     psa_drv_slot_number_t slot_number,
     psa_key_attributes_t *attributes,
     uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length )
diff --git a/tests/src/drivers/test_driver_signature.c b/tests/src/drivers/test_driver_signature.c
index 47c6deb..be8c179 100644
--- a/tests/src/drivers/test_driver_signature.c
+++ b/tests/src/drivers/test_driver_signature.c
@@ -41,28 +41,32 @@
 
 #include <string.h>
 
-test_driver_signature_hooks_t test_driver_signature_sign_hooks = TEST_DRIVER_SIGNATURE_INIT;
-test_driver_signature_hooks_t test_driver_signature_verify_hooks = TEST_DRIVER_SIGNATURE_INIT;
+mbedtls_test_driver_signature_hooks_t
+    mbedtls_test_driver_signature_sign_hooks = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
+mbedtls_test_driver_signature_hooks_t
+    mbedtls_test_driver_signature_verify_hooks = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
 
-psa_status_t test_transparent_signature_sign_hash(
+psa_status_t mbedtls_test_transparent_signature_sign_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key_buffer, size_t key_buffer_size,
     psa_algorithm_t alg,
     const uint8_t *hash, size_t hash_length,
     uint8_t *signature, size_t signature_size, size_t *signature_length )
 {
-    ++test_driver_signature_sign_hooks.hits;
+    ++mbedtls_test_driver_signature_sign_hooks.hits;
 
-    if( test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_signature_sign_hooks.forced_status );
+    if( mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_signature_sign_hooks.forced_status );
 
-    if( test_driver_signature_sign_hooks.forced_output != NULL )
+    if( mbedtls_test_driver_signature_sign_hooks.forced_output != NULL )
     {
-        if( test_driver_signature_sign_hooks.forced_output_length > signature_size )
+        if( mbedtls_test_driver_signature_sign_hooks.forced_output_length >
+            signature_size )
             return( PSA_ERROR_BUFFER_TOO_SMALL );
-        memcpy( signature, test_driver_signature_sign_hooks.forced_output,
-                test_driver_signature_sign_hooks.forced_output_length );
-        *signature_length = test_driver_signature_sign_hooks.forced_output_length;
+        memcpy( signature,
+                mbedtls_test_driver_signature_sign_hooks.forced_output,
+                mbedtls_test_driver_signature_sign_hooks.forced_output_length );
+        *signature_length = mbedtls_test_driver_signature_sign_hooks.forced_output_length;
         return( PSA_SUCCESS );
     }
 
@@ -120,7 +124,7 @@
     }
 }
 
-psa_status_t test_opaque_signature_sign_hash(
+psa_status_t mbedtls_test_opaque_signature_sign_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
@@ -140,17 +144,17 @@
     return( PSA_ERROR_NOT_SUPPORTED );
 }
 
-psa_status_t test_transparent_signature_verify_hash(
+psa_status_t mbedtls_test_transparent_signature_verify_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key_buffer, size_t key_buffer_size,
     psa_algorithm_t alg,
     const uint8_t *hash, size_t hash_length,
     const uint8_t *signature, size_t signature_length )
 {
-    ++test_driver_signature_verify_hooks.hits;
+    ++mbedtls_test_driver_signature_verify_hooks.hits;
 
-    if( test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS )
-        return( test_driver_signature_verify_hooks.forced_status );
+    if( mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS )
+        return( mbedtls_test_driver_signature_verify_hooks.forced_status );
 
 #if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) || \
     defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS)
@@ -200,7 +204,7 @@
     }
 }
 
-psa_status_t test_opaque_signature_verify_hash(
+psa_status_t mbedtls_test_opaque_signature_verify_hash(
     const psa_key_attributes_t *attributes,
     const uint8_t *key, size_t key_length,
     psa_algorithm_t alg,
diff --git a/tests/src/drivers/test_driver_size.c b/tests/src/drivers/test_driver_size.c
index 16a8692..fd10209 100644
--- a/tests/src/drivers/test_driver_size.c
+++ b/tests/src/drivers/test_driver_size.c
@@ -28,8 +28,8 @@
 
 #include "test/drivers/size.h"
 
-#ifdef TEST_KEY_CONTEXT_SIZE_FUNCTION
-size_t test_size_function(
+#ifdef MBEDTLS_TEST_KEY_CONTEXT_SIZE_FUNCTION
+size_t mbedtls_test_size_function(
     const psa_key_type_t key_type,
     const size_t key_bits )
 {
@@ -37,6 +37,6 @@
     (void) key_bits;
     return 0;
 }
-#endif /*TEST_KEY_CONTEXT_SIZE_FUNCTION */
+#endif /*MBEDTLS_TEST_KEY_CONTEXT_SIZE_FUNCTION */
 
 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/suites/test_suite_psa_crypto_driver_wrappers.function b/tests/suites/test_suite_psa_crypto_driver_wrappers.function
index f56c68b..9e53486 100644
--- a/tests/suites/test_suite_psa_crypto_driver_wrappers.function
+++ b/tests/suites/test_suite_psa_crypto_driver_wrappers.function
@@ -1,5 +1,5 @@
 /* BEGIN_HEADER */
-#include "test/drivers/test_driver.h"
+#include "test/drivers/mbedtls_test_driver.h"
 /* END_HEADER */
 
 /* BEGIN_DEPENDENCIES
@@ -23,7 +23,8 @@
     uint8_t signature[64];
     size_t signature_length = 0xdeadbeef;
     psa_status_t actual_status;
-    test_driver_signature_sign_hooks = test_driver_signature_hooks_init();
+    mbedtls_test_driver_signature_sign_hooks =
+        mbedtls_test_driver_signature_hooks_init();
 
     PSA_ASSERT( psa_crypto_init( ) );
     psa_set_key_type( &attributes,
@@ -34,11 +35,13 @@
                     key_input->x, key_input->len,
                     &key );
 
-    test_driver_signature_sign_hooks.forced_status = force_status;
+    mbedtls_test_driver_signature_sign_hooks.forced_status = force_status;
     if( fake_output == 1 )
     {
-        test_driver_signature_sign_hooks.forced_output = expected_output->x;
-        test_driver_signature_sign_hooks.forced_output_length = expected_output->len;
+        mbedtls_test_driver_signature_sign_hooks.forced_output =
+            expected_output->x;
+        mbedtls_test_driver_signature_sign_hooks.forced_output_length =
+            expected_output->len;
     }
 
     actual_status = psa_sign_hash( key, alg,
@@ -51,13 +54,14 @@
         ASSERT_COMPARE( signature, signature_length,
                         expected_output->x, expected_output->len );
     }
-    TEST_EQUAL( test_driver_signature_sign_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_signature_sign_hooks.hits, 1 );
 
 exit:
     psa_reset_key_attributes( &attributes );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_signature_sign_hooks = test_driver_signature_hooks_init();
+    mbedtls_test_driver_signature_sign_hooks =
+        mbedtls_test_driver_signature_hooks_init();
 }
 /* END_CASE */
 
@@ -75,7 +79,8 @@
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
     psa_algorithm_t alg = PSA_ALG_DETERMINISTIC_ECDSA( PSA_ALG_SHA_256 );
     psa_status_t actual_status;
-    test_driver_signature_verify_hooks = test_driver_signature_hooks_init();
+    mbedtls_test_driver_signature_verify_hooks =
+        mbedtls_test_driver_signature_hooks_init();
 
     PSA_ASSERT( psa_crypto_init( ) );
     if( register_public_key )
@@ -99,19 +104,20 @@
                         &key );
     }
 
-    test_driver_signature_verify_hooks.forced_status = force_status;
+    mbedtls_test_driver_signature_verify_hooks.forced_status = force_status;
 
     actual_status = psa_verify_hash( key, alg,
                                      data_input->x, data_input->len,
                                      signature_input->x, signature_input->len );
     TEST_EQUAL( actual_status, expected_status );
-    TEST_EQUAL( test_driver_signature_verify_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_signature_verify_hooks.hits, 1 );
 
 exit:
     psa_reset_key_attributes( &attributes );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_signature_verify_hooks = test_driver_signature_hooks_init();
+    mbedtls_test_driver_signature_verify_hooks =
+        mbedtls_test_driver_signature_hooks_init();
 }
 /* END_CASE */
 
@@ -130,7 +136,8 @@
     psa_status_t actual_status;
     uint8_t actual_output[PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(256)] = {0};
     size_t actual_output_length;
-    test_driver_key_management_hooks = test_driver_key_management_hooks_init();
+    mbedtls_test_driver_key_management_hooks =
+        mbedtls_test_driver_key_management_hooks_init();
 
     psa_set_key_type( &attributes,
                       PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ) );
@@ -140,18 +147,22 @@
 
     if( fake_output->len > 0 )
     {
-        expected_output = test_driver_key_management_hooks.forced_output = fake_output->x;
-        expected_output_length = test_driver_key_management_hooks.forced_output_length =
+        expected_output =
+            mbedtls_test_driver_key_management_hooks.forced_output =
+            fake_output->x;
+
+        expected_output_length =
+            mbedtls_test_driver_key_management_hooks.forced_output_length =
             fake_output->len;
     }
 
-    test_driver_key_management_hooks.hits = 0;
-    test_driver_key_management_hooks.forced_status = force_status;
+    mbedtls_test_driver_key_management_hooks.hits = 0;
+    mbedtls_test_driver_key_management_hooks.forced_status = force_status;
 
     PSA_ASSERT( psa_crypto_init( ) );
 
     actual_status = psa_generate_key( &attributes, &key );
-    TEST_EQUAL( test_driver_key_management_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_key_management_hooks.hits, 1 );
     TEST_EQUAL( actual_status, expected_status );
 
     if( actual_status == PSA_SUCCESS )
@@ -178,7 +189,8 @@
     psa_reset_key_attributes( &attributes );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_key_management_hooks = test_driver_key_management_hooks_init();
+    mbedtls_test_driver_key_management_hooks =
+        mbedtls_test_driver_key_management_hooks_init();
 }
 /* END_CASE */
 
@@ -194,25 +206,27 @@
     mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
     psa_status_t actual_status;
-    test_driver_key_management_hooks = test_driver_key_management_hooks_init();
+    mbedtls_test_driver_key_management_hooks =
+        mbedtls_test_driver_key_management_hooks_init();
 
     psa_set_key_type( &attributes,
                       key_type );
     psa_set_key_bits( &attributes, 0 );
     psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
 
-    test_driver_key_management_hooks.forced_status = force_status;
+    mbedtls_test_driver_key_management_hooks.forced_status = force_status;
 
     PSA_ASSERT( psa_crypto_init( ) );
 
     actual_status = psa_import_key( &attributes, key_input->x, key_input->len, &key );
-    TEST_EQUAL( test_driver_key_management_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_key_management_hooks.hits, 1 );
     TEST_EQUAL( actual_status, expected_status );
 exit:
     psa_reset_key_attributes( &attributes );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_key_management_hooks = test_driver_key_management_hooks_init();
+    mbedtls_test_driver_key_management_hooks =
+        mbedtls_test_driver_key_management_hooks_init();
 }
 /* END_CASE */
 
@@ -236,7 +250,8 @@
     psa_status_t actual_status;
     uint8_t actual_output[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(256)] = {0};
     size_t actual_output_length;
-    test_driver_key_management_hooks = test_driver_key_management_hooks_init();
+    mbedtls_test_driver_key_management_hooks =
+        mbedtls_test_driver_key_management_hooks_init();
 
     psa_set_key_type( &attributes, input_key_type );
     psa_set_key_bits( &attributes, 256 );
@@ -247,8 +262,12 @@
 
     if( fake_output->len > 0 )
     {
-        expected_output_ptr = test_driver_key_management_hooks.forced_output = fake_output->x;
-        expected_output_length = test_driver_key_management_hooks.forced_output_length =
+        expected_output_ptr =
+            mbedtls_test_driver_key_management_hooks.forced_output =
+            fake_output->x;
+
+        expected_output_length =
+            mbedtls_test_driver_key_management_hooks.forced_output_length =
             fake_output->len;
     }
     else
@@ -257,8 +276,8 @@
         expected_output_length = expected_output->len;
     }
 
-    test_driver_key_management_hooks.hits = 0;
-    test_driver_key_management_hooks.forced_status = force_status;
+    mbedtls_test_driver_key_management_hooks.hits = 0;
+    mbedtls_test_driver_key_management_hooks.forced_status = force_status;
 
     if( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( output_key_type ) )
         actual_status = psa_export_public_key( handle, actual_output, sizeof(actual_output), &actual_output_length );
@@ -268,7 +287,7 @@
 
     if( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( output_key_type ) &&
         !PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( input_key_type ) )
-        TEST_EQUAL( test_driver_key_management_hooks.hits, 1 );
+        TEST_EQUAL( mbedtls_test_driver_key_management_hooks.hits, 1 );
 
     if( actual_status == PSA_SUCCESS )
     {
@@ -279,7 +298,8 @@
     psa_reset_key_attributes( &attributes );
     psa_destroy_key( handle );
     PSA_DONE( );
-    test_driver_key_management_hooks = test_driver_key_management_hooks_init();
+    mbedtls_test_driver_key_management_hooks =
+        mbedtls_test_driver_key_management_hooks_init();
 }
 /* END_CASE */
 
@@ -303,8 +323,8 @@
     size_t total_output_length = 0;
     psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
-    test_driver_cipher_hooks.forced_status = force_status;
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks.forced_status = force_status;
 
     PSA_ASSERT( psa_crypto_init( ) );
 
@@ -316,12 +336,12 @@
                                 &key ) );
 
     PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     output_buffer_size = ( (size_t) input->len +
                            PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) );
@@ -329,21 +349,21 @@
 
     if( mock_output_arg )
     {
-        test_driver_cipher_hooks.forced_output = expected_output->x;
-        test_driver_cipher_hooks.forced_output_length = expected_output->len;
+        mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
+        mbedtls_test_driver_cipher_hooks.forced_output_length = expected_output->len;
     }
 
     PSA_ASSERT( psa_cipher_update( &operation,
                                    input->x, input->len,
                                    output, output_buffer_size,
                                    &function_output_length ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     if( mock_output_arg )
     {
-        test_driver_cipher_hooks.forced_output = NULL;
-        test_driver_cipher_hooks.forced_output_length = 0;
+        mbedtls_test_driver_cipher_hooks.forced_output = NULL;
+        mbedtls_test_driver_cipher_hooks.forced_output_length = 0;
     }
 
     total_output_length += function_output_length;
@@ -352,8 +372,8 @@
                                 output_buffer_size - total_output_length,
                                 &function_output_length );
     /* Finish will have called abort as well, so expecting two hits here */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 2 : 0 ) );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 2 : 0 ) );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     total_output_length += function_output_length;
 
@@ -362,7 +382,7 @@
     {
         PSA_ASSERT( psa_cipher_abort( &operation ) );
         // driver function should've been called as part of the finish() core routine
-        TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+        TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
         ASSERT_COMPARE( expected_output->x, expected_output->len,
                         output, total_output_length );
     }
@@ -372,7 +392,7 @@
     mbedtls_free( output );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 }
 /* END_CASE */
 
@@ -396,7 +416,7 @@
     size_t total_output_length = 0;
     psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 
     PSA_ASSERT( psa_crypto_init( ) );
 
@@ -408,12 +428,12 @@
                                 &key ) );
 
     PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     output_buffer_size = ( (size_t) input->len +
                            PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) );
@@ -423,8 +443,8 @@
     PSA_ASSERT( psa_cipher_update( &operation, input->x, first_part_size,
                                    output, output_buffer_size,
                                    &function_output_length ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     TEST_ASSERT( function_output_length == output1_length );
     total_output_length += function_output_length;
@@ -434,8 +454,8 @@
                                    output + total_output_length,
                                    output_buffer_size - total_output_length,
                                    &function_output_length ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     TEST_ASSERT( function_output_length == output2_length );
     total_output_length += function_output_length;
     PSA_ASSERT( psa_cipher_finish( &operation,
@@ -443,11 +463,11 @@
                                    output_buffer_size - total_output_length,
                                    &function_output_length ) );
     /* Finish will have called abort as well, so expecting two hits here */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 2 );
-    test_driver_cipher_hooks.hits = 0 ;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
+    mbedtls_test_driver_cipher_hooks.hits = 0 ;
     total_output_length += function_output_length;
     PSA_ASSERT( psa_cipher_abort( &operation ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
 
     ASSERT_COMPARE( expected_output->x, expected_output->len,
                     output, total_output_length );
@@ -457,7 +477,7 @@
     mbedtls_free( output );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 }
 /* END_CASE */
 
@@ -481,7 +501,7 @@
     size_t total_output_length = 0;
     psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 
     PSA_ASSERT( psa_crypto_init( ) );
 
@@ -493,12 +513,12 @@
                                 &key ) );
 
     PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     output_buffer_size = ( (size_t) input->len +
                            PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) );
@@ -509,8 +529,8 @@
                                    input->x, first_part_size,
                                    output, output_buffer_size,
                                    &function_output_length ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     TEST_ASSERT( function_output_length == output1_length );
     total_output_length += function_output_length;
@@ -520,8 +540,8 @@
                                    output + total_output_length,
                                    output_buffer_size - total_output_length,
                                    &function_output_length ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     TEST_ASSERT( function_output_length == output2_length );
     total_output_length += function_output_length;
@@ -530,11 +550,11 @@
                                    output_buffer_size - total_output_length,
                                    &function_output_length ) );
     /* Finish will have called abort as well, so expecting two hits here */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 2 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     total_output_length += function_output_length;
     PSA_ASSERT( psa_cipher_abort( &operation ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
 
     ASSERT_COMPARE( expected_output->x, expected_output->len,
                     output, total_output_length );
@@ -544,7 +564,7 @@
     mbedtls_free( output );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 }
 /* END_CASE */
 
@@ -568,8 +588,8 @@
     size_t total_output_length = 0;
     psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
-    test_driver_cipher_hooks.forced_status = force_status;
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks.forced_status = force_status;
 
     PSA_ASSERT( psa_crypto_init( ) );
 
@@ -581,12 +601,12 @@
                                 &key ) );
 
     PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     output_buffer_size = ( (size_t) input->len +
                            PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) );
@@ -594,21 +614,21 @@
 
     if( mock_output_arg )
     {
-        test_driver_cipher_hooks.forced_output = expected_output->x;
-        test_driver_cipher_hooks.forced_output_length = expected_output->len;
+        mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
+        mbedtls_test_driver_cipher_hooks.forced_output_length = expected_output->len;
     }
 
     PSA_ASSERT( psa_cipher_update( &operation,
                                    input->x, input->len,
                                    output, output_buffer_size,
                                    &function_output_length ) );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     if( mock_output_arg )
     {
-        test_driver_cipher_hooks.forced_output = NULL;
-        test_driver_cipher_hooks.forced_output_length = 0;
+        mbedtls_test_driver_cipher_hooks.forced_output = NULL;
+        mbedtls_test_driver_cipher_hooks.forced_output_length = 0;
     }
 
     total_output_length += function_output_length;
@@ -617,8 +637,8 @@
                                 output_buffer_size - total_output_length,
                                 &function_output_length );
     /* Finish will have called abort as well, so expecting two hits here */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 2 : 0 ) );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 2 : 0 ) );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     total_output_length += function_output_length;
     TEST_EQUAL( status, expected_status );
@@ -626,7 +646,7 @@
     if( expected_status == PSA_SUCCESS )
     {
         PSA_ASSERT( psa_cipher_abort( &operation ) );
-        TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+        TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
         ASSERT_COMPARE( expected_output->x, expected_output->len,
                         output, total_output_length );
     }
@@ -636,7 +656,7 @@
     mbedtls_free( output );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 }
 /* END_CASE */
 
@@ -654,7 +674,7 @@
     size_t function_output_length = 0;
     psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 
     ASSERT_ALLOC( output, input->len + 16 );
     output_buffer_size = input->len + 16;
@@ -669,136 +689,136 @@
                                 &key ) );
 
     /* Test setup call, encrypt */
-    test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
     status = psa_cipher_encrypt_setup( &operation, key, alg );
     /* When setup fails, it shouldn't call any further entry points */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     status = psa_cipher_set_iv( &operation, iv->x, iv->len );
     TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
 
     /* Test setup call failure, decrypt */
     status = psa_cipher_decrypt_setup( &operation, key, alg );
     /* When setup fails, it shouldn't call any further entry points */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     status = psa_cipher_set_iv( &operation, iv->x, iv->len );
     TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
 
     /* Test IV setting failure */
-    test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
     status = psa_cipher_encrypt_setup( &operation, key, alg );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
-    test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
     status = psa_cipher_set_iv( &operation, iv->x, iv->len );
     /* When setting the IV fails, it should call abort too */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 2 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
     /* Failure should prevent further operations from executing on the driver */
-    test_driver_cipher_hooks.hits = 0;
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     status = psa_cipher_update( &operation,
                                 input->x, input->len,
                                 output, output_buffer_size,
                                 &function_output_length );
     TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
     psa_cipher_abort( &operation );
 
     /* Test IV generation failure */
-    test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
     status = psa_cipher_encrypt_setup( &operation, key, alg );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
-    test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
     status = psa_cipher_generate_iv( &operation, output, 16, &function_output_length );
     /* When generating the IV fails, it should call abort too */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 2 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
     /* Failure should prevent further operations from executing on the driver */
-    test_driver_cipher_hooks.hits = 0;
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     status = psa_cipher_update( &operation,
                                 input->x, input->len,
                                 output, output_buffer_size,
                                 &function_output_length );
     TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
     psa_cipher_abort( &operation );
 
     /* Test update failure */
-    test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
     status = psa_cipher_encrypt_setup( &operation, key, alg );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     status = psa_cipher_set_iv( &operation, iv->x, iv->len );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
-    test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
     status = psa_cipher_update( &operation,
                                 input->x, input->len,
                                 output, output_buffer_size,
                                 &function_output_length );
     /* When the update call fails, it should call abort too */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 2 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
     /* Failure should prevent further operations from executing on the driver */
-    test_driver_cipher_hooks.hits = 0;
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     status = psa_cipher_update( &operation,
                                 input->x, input->len,
                                 output, output_buffer_size,
                                 &function_output_length );
     TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
     psa_cipher_abort( &operation );
 
     /* Test finish failure */
-    test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
     status = psa_cipher_encrypt_setup( &operation, key, alg );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     status = psa_cipher_set_iv( &operation, iv->x, iv->len );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
     status = psa_cipher_update( &operation,
                                 input->x, input->len,
                                 output, output_buffer_size,
                                 &function_output_length );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 1 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
-    test_driver_cipher_hooks.hits = 0;
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+    mbedtls_test_driver_cipher_hooks.hits = 0;
 
-    test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
+    mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
     status = psa_cipher_finish( &operation,
                                 output + function_output_length,
                                 output_buffer_size - function_output_length,
                                 &function_output_length );
     /* When the finish call fails, it should call abort too */
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 2 );
-    TEST_EQUAL( status, test_driver_cipher_hooks.forced_status );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
+    TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
     /* Failure should prevent further operations from executing on the driver */
-    test_driver_cipher_hooks.hits = 0;
+    mbedtls_test_driver_cipher_hooks.hits = 0;
     status = psa_cipher_update( &operation,
                                 input->x, input->len,
                                 output, output_buffer_size,
                                 &function_output_length );
     TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
-    TEST_EQUAL( test_driver_cipher_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
     psa_cipher_abort( &operation );
 
 exit:
@@ -806,7 +826,7 @@
     mbedtls_free( output );
     psa_destroy_key( key );
     PSA_DONE( );
-    test_driver_cipher_hooks = test_driver_cipher_hooks_init();
+    mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
 }
 /* END_CASE */
 
@@ -829,7 +849,7 @@
     size_t output_length = 0;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
     psa_status_t status = PSA_ERROR_GENERIC_ERROR;
-    test_driver_aead_hooks = test_driver_aead_hooks_init();
+    mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
 
     PSA_ASSERT( psa_crypto_init( ) );
 
@@ -852,15 +872,15 @@
                  PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
     ASSERT_ALLOC( output_data, output_size );
 
-    test_driver_aead_hooks.forced_status = forced_status;
+    mbedtls_test_driver_aead_hooks.forced_status = forced_status;
     status = psa_aead_encrypt( key, alg,
                                nonce->x, nonce->len,
                                additional_data->x, additional_data->len,
                                input_data->x, input_data->len,
                                output_data, output_size,
                                &output_length );
-    TEST_EQUAL( test_driver_aead_hooks.hits, 1 );
-    TEST_EQUAL( test_driver_aead_hooks.driver_status, forced_status );
+    TEST_EQUAL( mbedtls_test_driver_aead_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_aead_hooks.driver_status, forced_status );
 
     TEST_EQUAL( status, ( forced_status == PSA_ERROR_NOT_SUPPORTED ) ?
                         PSA_SUCCESS : forced_status );
@@ -875,7 +895,7 @@
     psa_destroy_key( key );
     mbedtls_free( output_data );
     PSA_DONE( );
-    test_driver_aead_hooks = test_driver_aead_hooks_init();
+    mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
 }
 /* END_CASE */
 
@@ -898,7 +918,7 @@
     size_t output_length = 0;
     psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
     psa_status_t status = PSA_ERROR_GENERIC_ERROR;
-    test_driver_aead_hooks = test_driver_aead_hooks_init();
+    mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
 
     PSA_ASSERT( psa_crypto_init( ) );
 
@@ -915,7 +935,7 @@
                                                          alg );
     ASSERT_ALLOC( output_data, output_size );
 
-    test_driver_aead_hooks.forced_status = forced_status;
+    mbedtls_test_driver_aead_hooks.forced_status = forced_status;
     status = psa_aead_decrypt( key, alg,
                                nonce->x, nonce->len,
                                additional_data->x,
@@ -923,8 +943,8 @@
                                input_data->x, input_data->len,
                                output_data, output_size,
                                &output_length );
-    TEST_EQUAL( test_driver_aead_hooks.hits, 1 );
-    TEST_EQUAL( test_driver_aead_hooks.driver_status, forced_status );
+    TEST_EQUAL( mbedtls_test_driver_aead_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_aead_hooks.driver_status, forced_status );
 
     TEST_EQUAL( status, ( forced_status == PSA_ERROR_NOT_SUPPORTED ) ?
                         PSA_SUCCESS : forced_status );
@@ -939,7 +959,7 @@
     psa_destroy_key( key );
     mbedtls_free( output_data );
     PSA_DONE( );
-    test_driver_aead_hooks = test_driver_aead_hooks_init();
+    mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
 }
 /* END_CASE */
 
@@ -1059,8 +1079,8 @@
     unsigned char *output = NULL;
     size_t output_length;
 
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
-    test_driver_hash_hooks.forced_status = forced_status;
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks.forced_status = forced_status;
 
     PSA_ASSERT( psa_crypto_init( ) );
     ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
@@ -1068,8 +1088,8 @@
     TEST_EQUAL( psa_hash_compute( alg, input->x, input->len,
                                   output, PSA_HASH_LENGTH( alg ),
                                   &output_length ), expected_status );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 1 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
     if( expected_status == PSA_SUCCESS )
     {
@@ -1079,7 +1099,7 @@
 exit:
     mbedtls_free( output );
     PSA_DONE( );
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
 }
 /* END_CASE */
 
@@ -1096,7 +1116,7 @@
     psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
     size_t output_length;
 
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
     ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
 
     PSA_ASSERT( psa_crypto_init( ) );
@@ -1104,24 +1124,24 @@
     /*
      * Case 1: Force the driver return status for setup.
      */
-    test_driver_hash_hooks.forced_status = forced_status;
+    mbedtls_test_driver_hash_hooks.forced_status = forced_status;
     TEST_EQUAL( psa_hash_setup( &operation, alg ), expected_status );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 1 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
     if( expected_status == PSA_SUCCESS )
     {
         PSA_ASSERT( psa_hash_update( &operation, input->x, input->len ) );
-        TEST_EQUAL( test_driver_hash_hooks.hits,
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
                     forced_status == PSA_ERROR_NOT_SUPPORTED ? 1 : 2 );
-        TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
         PSA_ASSERT( psa_hash_finish( &operation,
                                      output, PSA_HASH_LENGTH( alg ),
                                      &output_length ) );
-        TEST_EQUAL( test_driver_hash_hooks.hits,
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
                     forced_status == PSA_ERROR_NOT_SUPPORTED ? 1 : 4 );
-        TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
         ASSERT_COMPARE( output, output_length, hash->x, hash->len );
     }
@@ -1129,25 +1149,25 @@
     /*
      * Case 2: Force the driver return status for update.
      */
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
     PSA_ASSERT( psa_hash_setup( &operation, alg ) );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 1 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
 
-    test_driver_hash_hooks.forced_status = forced_status;
+    mbedtls_test_driver_hash_hooks.forced_status = forced_status;
     TEST_EQUAL( psa_hash_update( &operation, input->x, input->len ),
                                  forced_status );
-    TEST_EQUAL( test_driver_hash_hooks.hits,
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
                 forced_status != PSA_SUCCESS ? 3 : 2 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
     if( forced_status == PSA_SUCCESS )
     {
         PSA_ASSERT( psa_hash_finish( &operation,
                                      output, PSA_HASH_LENGTH( alg ),
                                      &output_length ) );
-        TEST_EQUAL( test_driver_hash_hooks.hits, 4 );
-        TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 4 );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
         ASSERT_COMPARE( output, output_length, hash->x, hash->len );
     }
@@ -1155,21 +1175,21 @@
     /*
      * Case 3: Force the driver return status for finish.
      */
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
     PSA_ASSERT( psa_hash_setup( &operation, alg ) );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 1 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
 
     PSA_ASSERT( psa_hash_update( &operation, input->x, input->len ) );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 2 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 2 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
 
-    test_driver_hash_hooks.forced_status = forced_status;
+    mbedtls_test_driver_hash_hooks.forced_status = forced_status;
     TEST_EQUAL( psa_hash_finish( &operation,
                                  output, PSA_HASH_LENGTH( alg ),
                                  &output_length ), forced_status );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 4 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 4 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
     if( forced_status == PSA_SUCCESS )
     {
@@ -1180,7 +1200,7 @@
     psa_hash_abort( &operation );
     mbedtls_free( output );
     PSA_DONE( );
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
 }
 /* END_CASE */
 
@@ -1196,7 +1216,7 @@
     psa_hash_operation_t target_operation = PSA_HASH_OPERATION_INIT;
     size_t output_length;
 
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
     ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
 
     PSA_ASSERT( psa_crypto_init( ) );
@@ -1206,32 +1226,32 @@
      */
     TEST_EQUAL( psa_hash_clone( &source_operation, &target_operation ),
                 PSA_ERROR_BAD_STATE );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 0 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 0 );
 
     PSA_ASSERT( psa_hash_setup( &source_operation, alg ) );
-    TEST_EQUAL( test_driver_hash_hooks.hits, 1 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
 
-    test_driver_hash_hooks.forced_status = forced_status;
+    mbedtls_test_driver_hash_hooks.forced_status = forced_status;
     TEST_EQUAL( psa_hash_clone( &source_operation, &target_operation ),
                 forced_status );
-    TEST_EQUAL( test_driver_hash_hooks.hits,
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
                 forced_status == PSA_SUCCESS ? 2 : 3 );
-    TEST_EQUAL( test_driver_hash_hooks.driver_status, forced_status );
+    TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
 
     if( forced_status == PSA_SUCCESS )
     {
-        test_driver_hash_hooks = test_driver_hash_hooks_init();
+        mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
         PSA_ASSERT( psa_hash_update( &target_operation,
                                      input->x, input->len ) );
-        TEST_EQUAL( test_driver_hash_hooks.hits, 1 );
-        TEST_EQUAL( test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
 
         PSA_ASSERT( psa_hash_finish( &target_operation,
                                      output, PSA_HASH_LENGTH( alg ),
                                      &output_length ) );
-        TEST_EQUAL( test_driver_hash_hooks.hits, 3 );
-        TEST_EQUAL( test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 3 );
+        TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
 
         ASSERT_COMPARE( output, output_length, hash->x, hash->len );
     }
@@ -1241,6 +1261,6 @@
     psa_hash_abort( &target_operation );
     mbedtls_free( output );
     PSA_DONE( );
-    test_driver_hash_hooks = test_driver_hash_hooks_init();
+    mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
 }
 /* END_CASE */