diff --git a/tests/src/asn1_helpers.c b/tests/src/asn1_helpers.c
index 79aa166..8ece1e3 100644
--- a/tests/src/asn1_helpers.c
+++ b/tests/src/asn1_helpers.c
@@ -52,7 +52,7 @@
         --len;
     }
     if( min_bits == 0 && len == 0 )
-        return( 1 );
+        return 1 ;
     msb = ( *p )[0];
     TEST_ASSERT( msb != 0 );
     actual_bits = 8 * ( len - 1 );
@@ -66,9 +66,9 @@
     if( must_be_odd )
         TEST_ASSERT( ( ( *p )[len-1] & 1 ) != 0 );
     *p += len;
-    return( 1 );
+    return 1 ;
 exit:
-    return( 0 );
+    return 0 ;
 }
 
 #endif /* MBEDTLS_ASN1_PARSE_C */
diff --git a/tests/src/drivers/hash.c b/tests/src/drivers/hash.c
index b1880f7..d57ce6c 100644
--- a/tests/src/drivers/hash.c
+++ b/tests/src/drivers/hash.c
@@ -47,7 +47,7 @@
                 hash, hash_size, hash_length );
     }
 
-    return( mbedtls_test_driver_hash_hooks.driver_status );
+    return mbedtls_test_driver_hash_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_hash_setup(
@@ -67,7 +67,7 @@
             mbedtls_transparent_test_driver_hash_setup( operation, alg );
     }
 
-    return( mbedtls_test_driver_hash_hooks.driver_status );
+    return mbedtls_test_driver_hash_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_hash_clone(
@@ -88,7 +88,7 @@
                                                         target_operation );
     }
 
-    return( mbedtls_test_driver_hash_hooks.driver_status );
+    return mbedtls_test_driver_hash_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_hash_update(
@@ -110,7 +110,7 @@
                 operation, input, input_length );
     }
 
-    return( mbedtls_test_driver_hash_hooks.driver_status );
+    return mbedtls_test_driver_hash_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_hash_finish(
@@ -133,7 +133,7 @@
                 operation, hash, hash_size, hash_length );
     }
 
-    return( mbedtls_test_driver_hash_hooks.driver_status );
+    return mbedtls_test_driver_hash_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_hash_abort(
@@ -152,6 +152,6 @@
             mbedtls_transparent_test_driver_hash_abort( operation );
     }
 
-    return( mbedtls_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 da5865d..6d125a0 100644
--- a/tests/src/drivers/platform_builtin_keys.c
+++ b/tests/src/drivers/platform_builtin_keys.c
@@ -85,9 +85,9 @@
         {
             *lifetime = builtin_key->lifetime;
             *slot_number = builtin_key->slot_number;
-            return( PSA_SUCCESS );
+            return PSA_SUCCESS ;
         }
     }
 
-    return( PSA_ERROR_DOES_NOT_EXIST );
+    return PSA_ERROR_DOES_NOT_EXIST ;
 }
diff --git a/tests/src/drivers/test_driver_aead.c b/tests/src/drivers/test_driver_aead.c
index ce9ce37..76afcd7 100644
--- a/tests/src/drivers/test_driver_aead.c
+++ b/tests/src/drivers/test_driver_aead.c
@@ -55,7 +55,7 @@
                 ciphertext, ciphertext_size, ciphertext_length );
     }
 
-    return( mbedtls_test_driver_aead_hooks.driver_status );
+    return mbedtls_test_driver_aead_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_aead_decrypt(
@@ -86,7 +86,7 @@
                 plaintext, plaintext_size, plaintext_length );
     }
 
-    return( mbedtls_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 89a7b59..20d79d8 100644
--- a/tests/src/drivers/test_driver_cipher.c
+++ b/tests/src/drivers/test_driver_cipher.c
@@ -51,18 +51,18 @@
     if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
     {
         if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
-            return( PSA_ERROR_BUFFER_TOO_SMALL );
+            return PSA_ERROR_BUFFER_TOO_SMALL ;
 
         memcpy( output,
                 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( mbedtls_test_driver_cipher_hooks.forced_status );
+        return mbedtls_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_test_driver_cipher_hooks.forced_status ;
 
     psa_generate_random( output, PSA_CIPHER_IV_LENGTH( attributes->core.type, alg ) );
 
@@ -88,18 +88,18 @@
     if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
     {
         if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
-            return( PSA_ERROR_BUFFER_TOO_SMALL );
+            return PSA_ERROR_BUFFER_TOO_SMALL ;
 
         memcpy( output,
                 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( mbedtls_test_driver_cipher_hooks.forced_status );
+        return mbedtls_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_test_driver_cipher_hooks.forced_status ;
 
     return( mbedtls_transparent_test_driver_cipher_decrypt(
                 attributes, key_buffer, key_buffer_size,
@@ -122,7 +122,7 @@
     memset( operation, 0, sizeof( *operation ) );
 
     if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_cipher_hooks.forced_status );
+        return mbedtls_test_driver_cipher_hooks.forced_status ;
 
     return ( mbedtls_transparent_test_driver_cipher_encrypt_setup(
                  operation, attributes, key, key_length, alg ) );
@@ -137,7 +137,7 @@
     mbedtls_test_driver_cipher_hooks.hits++;
 
     if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_cipher_hooks.forced_status );
+        return mbedtls_test_driver_cipher_hooks.forced_status ;
 
     return ( mbedtls_transparent_test_driver_cipher_decrypt_setup(
                  operation, attributes, key, key_length, alg ) );
@@ -149,7 +149,7 @@
     mbedtls_test_driver_cipher_hooks.hits++;
 
     if( operation->alg == 0 )
-        return( PSA_SUCCESS );
+        return PSA_SUCCESS ;
 
     mbedtls_transparent_test_driver_cipher_abort( operation );
 
@@ -159,7 +159,7 @@
      * our context struct. */
     memset( operation, 0, sizeof( *operation ) );
 
-    return( mbedtls_test_driver_cipher_hooks.forced_status );
+    return mbedtls_test_driver_cipher_hooks.forced_status ;
 }
 
 psa_status_t mbedtls_test_transparent_cipher_set_iv(
@@ -170,7 +170,7 @@
     mbedtls_test_driver_cipher_hooks.hits++;
 
     if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_cipher_hooks.forced_status );
+        return mbedtls_test_driver_cipher_hooks.forced_status ;
 
     return( mbedtls_transparent_test_driver_cipher_set_iv(
                 operation, iv, iv_length ) );
@@ -196,11 +196,11 @@
                 mbedtls_test_driver_cipher_hooks.forced_output_length );
         *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
 
-        return( mbedtls_test_driver_cipher_hooks.forced_status );
+        return mbedtls_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_test_driver_cipher_hooks.forced_status ;
 
     return( mbedtls_transparent_test_driver_cipher_update(
                 operation, input, input_length,
@@ -225,11 +225,11 @@
                 mbedtls_test_driver_cipher_hooks.forced_output_length );
         *output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
 
-        return( mbedtls_test_driver_cipher_hooks.forced_status );
+        return mbedtls_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_test_driver_cipher_hooks.forced_status ;
 
     return( mbedtls_transparent_test_driver_cipher_finish(
                 operation, output, output_size, output_length ) );
@@ -254,7 +254,7 @@
     (void) output;
     (void) output_size;
     (void) output_length;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_opaque_cipher_decrypt(
@@ -273,7 +273,7 @@
     (void) output;
     (void) output_size;
     (void) output_length;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_opaque_cipher_encrypt_setup(
@@ -287,7 +287,7 @@
     (void) key;
     (void) key_length;
     (void) alg;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_opaque_cipher_decrypt_setup(
@@ -301,14 +301,14 @@
     (void) key;
     (void) key_length;
     (void) alg;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_opaque_cipher_abort(
     mbedtls_opaque_test_driver_cipher_operation_t *operation )
 {
     (void) operation;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_opaque_cipher_set_iv(
@@ -319,7 +319,7 @@
     (void) operation;
     (void) iv;
     (void) iv_length;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_opaque_cipher_update(
@@ -336,7 +336,7 @@
     (void) output;
     (void) output_size;
     (void) output_length;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_opaque_cipher_finish(
@@ -349,6 +349,6 @@
     (void) output;
     (void) output_size;
     (void) output_length;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_key_management.c b/tests/src/drivers/test_driver_key_management.c
index afa1fc2..d2bc9b8 100644
--- a/tests/src/drivers/test_driver_key_management.c
+++ b/tests/src/drivers/test_driver_key_management.c
@@ -63,17 +63,17 @@
     ++mbedtls_test_driver_key_management_hooks.hits;
 
     if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_key_management_hooks.forced_status );
+        return mbedtls_test_driver_key_management_hooks.forced_status ;
 
     if( mbedtls_test_driver_key_management_hooks.forced_output != NULL )
     {
         if( mbedtls_test_driver_key_management_hooks.forced_output_length >
             key_size )
-            return( PSA_ERROR_BUFFER_TOO_SMALL );
+            return PSA_ERROR_BUFFER_TOO_SMALL ;
         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 );
+        return PSA_SUCCESS ;
     }
 
     /* Copied from psa_crypto.c */
@@ -95,7 +95,7 @@
 #endif /* defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) */
     {
         (void)attributes;
-        return( PSA_ERROR_NOT_SUPPORTED );
+        return PSA_ERROR_NOT_SUPPORTED ;
     }
 }
 
@@ -107,7 +107,7 @@
     (void) key;
     (void) key_size;
     (void) key_length;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_transparent_import_key(
@@ -122,7 +122,7 @@
     ++mbedtls_test_driver_key_management_hooks.hits;
 
     if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_key_management_hooks.forced_status );
+        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 );
@@ -162,7 +162,7 @@
         (void)type;
     }
 
-    return( status );
+    return status ;
 }
 
 psa_status_t mbedtls_test_opaque_export_key(
@@ -173,7 +173,7 @@
     if( key_length != sizeof( psa_drv_slot_number_t ) )
     {
         /* Test driver does not support generic opaque key handling yet. */
-        return( PSA_ERROR_NOT_SUPPORTED );
+        return PSA_ERROR_NOT_SUPPORTED ;
     }
 
     /* Assume this is a builtin key based on the key material length. */
@@ -186,47 +186,47 @@
              * returning the private key. */
             if( psa_get_key_type( attributes ) !=
                 PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 ) )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( psa_get_key_bits( attributes ) != 256 )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( psa_get_key_algorithm( attributes ) !=
                 PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( ( psa_get_key_usage_flags( attributes ) &
                   PSA_KEY_USAGE_EXPORT ) == 0 )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
 
             if( data_size < sizeof( mbedtls_test_driver_ecdsa_key ) )
-                return( PSA_ERROR_BUFFER_TOO_SMALL );
+                return PSA_ERROR_BUFFER_TOO_SMALL ;
 
             memcpy( data, mbedtls_test_driver_ecdsa_key,
                     sizeof( mbedtls_test_driver_ecdsa_key ) );
             *data_length = sizeof( mbedtls_test_driver_ecdsa_key );
-            return( PSA_SUCCESS );
+            return PSA_SUCCESS ;
 
         case PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT:
             /* This is the AES slot. Verify the key's attributes before
              * returning the key. */
             if( psa_get_key_type( attributes ) != PSA_KEY_TYPE_AES )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( psa_get_key_bits( attributes ) != 128 )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( psa_get_key_algorithm( attributes ) != PSA_ALG_CTR )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( ( psa_get_key_usage_flags( attributes ) &
                   PSA_KEY_USAGE_EXPORT ) == 0 )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
 
             if( data_size < sizeof( mbedtls_test_driver_aes_key ) )
-                return( PSA_ERROR_BUFFER_TOO_SMALL );
+                return PSA_ERROR_BUFFER_TOO_SMALL ;
 
             memcpy( data, mbedtls_test_driver_aes_key,
                     sizeof( mbedtls_test_driver_aes_key ) );
             *data_length = sizeof( mbedtls_test_driver_aes_key );
-            return( PSA_SUCCESS );
+            return PSA_SUCCESS ;
 
         default:
-            return( PSA_ERROR_DOES_NOT_EXIST );
+            return PSA_ERROR_DOES_NOT_EXIST ;
     }
 }
 
@@ -238,17 +238,17 @@
     ++mbedtls_test_driver_key_management_hooks.hits;
 
     if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_key_management_hooks.forced_status );
+        return mbedtls_test_driver_key_management_hooks.forced_status ;
 
     if( mbedtls_test_driver_key_management_hooks.forced_output != NULL )
     {
         if( mbedtls_test_driver_key_management_hooks.forced_output_length >
             data_size )
-            return( PSA_ERROR_BUFFER_TOO_SMALL );
+            return PSA_ERROR_BUFFER_TOO_SMALL ;
         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 );
+        return PSA_SUCCESS ;
     }
 
     psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
@@ -283,7 +283,7 @@
         (void)key_type;
     }
 
-    return( status );
+    return status ;
 }
 
 psa_status_t mbedtls_test_opaque_export_public_key(
@@ -294,7 +294,7 @@
     if( key_length != sizeof( psa_drv_slot_number_t ) )
     {
         /* Test driver does not support generic opaque key handling yet. */
-        return( PSA_ERROR_NOT_SUPPORTED );
+        return PSA_ERROR_NOT_SUPPORTED ;
     }
 
     /* Assume this is a builtin key based on the key material length. */
@@ -306,23 +306,23 @@
              * returning the public key. */
             if( psa_get_key_type( attributes ) !=
                 PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 ) )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( psa_get_key_bits( attributes ) != 256 )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
             if( psa_get_key_algorithm( attributes ) !=
                 PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) )
-                return( PSA_ERROR_CORRUPTION_DETECTED );
+                return PSA_ERROR_CORRUPTION_DETECTED ;
 
             if( data_size < sizeof( mbedtls_test_driver_ecdsa_pubkey ) )
-                return( PSA_ERROR_BUFFER_TOO_SMALL );
+                return PSA_ERROR_BUFFER_TOO_SMALL ;
 
             memcpy( data, mbedtls_test_driver_ecdsa_pubkey,
                     sizeof( mbedtls_test_driver_ecdsa_pubkey ) );
             *data_length = sizeof( mbedtls_test_driver_ecdsa_pubkey );
-            return( PSA_SUCCESS );
+            return PSA_SUCCESS ;
 
         default:
-            return( PSA_ERROR_DOES_NOT_EXIST );
+            return PSA_ERROR_DOES_NOT_EXIST ;
     }
 }
 
@@ -354,12 +354,12 @@
             psa_set_key_algorithm( attributes, PSA_ALG_CTR );
 
             if( key_buffer_size < sizeof( psa_drv_slot_number_t ) )
-                return( PSA_ERROR_BUFFER_TOO_SMALL );
+                return PSA_ERROR_BUFFER_TOO_SMALL ;
 
             *( (psa_drv_slot_number_t*) key_buffer ) =
                 PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT;
             *key_buffer_length = sizeof( psa_drv_slot_number_t );
-            return( PSA_SUCCESS );
+            return PSA_SUCCESS ;
         case PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT:
             psa_set_key_type(
                 attributes,
@@ -374,14 +374,14 @@
                 attributes, PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) );
 
             if( key_buffer_size < sizeof( psa_drv_slot_number_t ) )
-                return( PSA_ERROR_BUFFER_TOO_SMALL );
+                return PSA_ERROR_BUFFER_TOO_SMALL ;
 
             *( (psa_drv_slot_number_t*) key_buffer ) =
                 PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT;
             *key_buffer_length = sizeof( psa_drv_slot_number_t );
-            return( PSA_SUCCESS );
+            return PSA_SUCCESS ;
         default:
-            return( PSA_ERROR_DOES_NOT_EXIST );
+            return PSA_ERROR_DOES_NOT_EXIST ;
     }
 }
 
diff --git a/tests/src/drivers/test_driver_mac.c b/tests/src/drivers/test_driver_mac.c
index 3b766dc..cfcf162 100644
--- a/tests/src/drivers/test_driver_mac.c
+++ b/tests/src/drivers/test_driver_mac.c
@@ -54,7 +54,7 @@
                 mac, mac_size, mac_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_mac_sign_setup(
@@ -78,7 +78,7 @@
                 operation, attributes, key_buffer, key_buffer_size, alg );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_mac_verify_setup(
@@ -102,7 +102,7 @@
                 operation, attributes, key_buffer, key_buffer_size, alg );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_mac_update(
@@ -124,7 +124,7 @@
                 operation, input, input_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_mac_sign_finish(
@@ -147,7 +147,7 @@
                 operation, mac, mac_size, mac_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_mac_verify_finish(
@@ -169,7 +169,7 @@
                 operation, mac, mac_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_transparent_mac_abort(
@@ -188,7 +188,7 @@
             mbedtls_transparent_test_driver_mac_abort( operation );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_opaque_mac_compute(
@@ -218,7 +218,7 @@
                 mac, mac_size, mac_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_opaque_mac_sign_setup(
@@ -242,7 +242,7 @@
                 operation, attributes, key_buffer, key_buffer_size, alg );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_opaque_mac_verify_setup(
@@ -266,7 +266,7 @@
                 operation, attributes, key_buffer, key_buffer_size, alg );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_opaque_mac_update(
@@ -288,7 +288,7 @@
                 operation, input, input_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_opaque_mac_sign_finish(
@@ -311,7 +311,7 @@
                 operation, mac, mac_size, mac_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_opaque_mac_verify_finish(
@@ -333,7 +333,7 @@
                 operation, mac, mac_length );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 psa_status_t mbedtls_test_opaque_mac_abort(
@@ -352,7 +352,7 @@
             mbedtls_opaque_test_driver_mac_abort( operation );
     }
 
-    return( mbedtls_test_driver_mac_hooks.driver_status );
+    return mbedtls_test_driver_mac_hooks.driver_status ;
 }
 
 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_signature.c b/tests/src/drivers/test_driver_signature.c
index 2d58756..e573b72 100644
--- a/tests/src/drivers/test_driver_signature.c
+++ b/tests/src/drivers/test_driver_signature.c
@@ -88,7 +88,7 @@
         }
         else
         {
-            return( PSA_ERROR_INVALID_ARGUMENT );
+            return PSA_ERROR_INVALID_ARGUMENT ;
         }
     }
     else
@@ -104,7 +104,7 @@
         (void)signature;
         (void)signature_size;
         (void)signature_length;
-        return( PSA_ERROR_NOT_SUPPORTED );
+        return PSA_ERROR_NOT_SUPPORTED ;
     }
 }
 
@@ -146,7 +146,7 @@
         }
         else
         {
-            return( PSA_ERROR_INVALID_ARGUMENT );
+            return PSA_ERROR_INVALID_ARGUMENT ;
         }
     }
     else
@@ -162,7 +162,7 @@
         (void)signature;
         (void)signature_length;
 
-        return( PSA_ERROR_NOT_SUPPORTED );
+        return PSA_ERROR_NOT_SUPPORTED ;
     }
 }
 
@@ -184,18 +184,18 @@
     ++mbedtls_test_driver_signature_sign_hooks.hits;
 
     if( mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_signature_sign_hooks.forced_status );
+        return mbedtls_test_driver_signature_sign_hooks.forced_status ;
 
     if( mbedtls_test_driver_signature_sign_hooks.forced_output != NULL )
     {
         if( mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size )
-            return( PSA_ERROR_BUFFER_TOO_SMALL );
+            return PSA_ERROR_BUFFER_TOO_SMALL ;
 
         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 );
+        return PSA_SUCCESS ;
     }
 
     status = mbedtls_transparent_test_driver_hash_compute(
@@ -231,7 +231,7 @@
     (void) signature_size;
     (void) signature_length;
 
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_transparent_signature_verify_message(
@@ -251,7 +251,7 @@
     ++mbedtls_test_driver_signature_verify_hooks.hits;
 
     if( mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_signature_verify_hooks.forced_status );
+        return mbedtls_test_driver_signature_verify_hooks.forced_status ;
 
     status = mbedtls_transparent_test_driver_hash_compute(
                 PSA_ALG_SIGN_GET_HASH( alg ), input, input_length,
@@ -284,7 +284,7 @@
     (void) signature;
     (void) signature_length;
 
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_transparent_signature_sign_hash(
@@ -297,16 +297,16 @@
     ++mbedtls_test_driver_signature_sign_hooks.hits;
 
     if( mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_signature_sign_hooks.forced_status );
+        return mbedtls_test_driver_signature_sign_hooks.forced_status ;
 
     if( mbedtls_test_driver_signature_sign_hooks.forced_output != NULL )
     {
         if( mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size )
-            return( PSA_ERROR_BUFFER_TOO_SMALL );
+            return PSA_ERROR_BUFFER_TOO_SMALL ;
         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 );
+        return PSA_SUCCESS ;
     }
 
     return sign_hash( attributes, key_buffer, key_buffer_size,
@@ -331,7 +331,7 @@
     (void) signature_size;
     (void) signature_length;
 
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 psa_status_t mbedtls_test_transparent_signature_verify_hash(
@@ -344,7 +344,7 @@
     ++mbedtls_test_driver_signature_verify_hooks.hits;
 
     if( mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS )
-        return( mbedtls_test_driver_signature_verify_hooks.forced_status );
+        return mbedtls_test_driver_signature_verify_hooks.forced_status ;
 
     return verify_hash( attributes, key_buffer, key_buffer_size,
                         alg, hash, hash_length,
@@ -366,7 +366,7 @@
     (void) hash_length;
     (void) signature;
     (void) signature_length;
-    return( PSA_ERROR_NOT_SUPPORTED );
+    return PSA_ERROR_NOT_SUPPORTED ;
 }
 
 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_size.c b/tests/src/drivers/test_driver_size.c
index 033cf32..837d82a 100644
--- a/tests/src/drivers/test_driver_size.c
+++ b/tests/src/drivers/test_driver_size.c
@@ -92,6 +92,6 @@
                             ( ( key_bits + 7 ) / 8 ) );
     }
 
-    return( key_buffer_size );
+    return key_buffer_size ;
 }
 #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/fake_external_rng_for_test.c b/tests/src/fake_external_rng_for_test.c
index 9c2195b..ec83541 100644
--- a/tests/src/fake_external_rng_for_test.c
+++ b/tests/src/fake_external_rng_for_test.c
@@ -45,12 +45,12 @@
     (void) context;
 
     if( !test_insecure_external_rng_enabled )
-        return( PSA_ERROR_INSUFFICIENT_ENTROPY );
+        return PSA_ERROR_INSUFFICIENT_ENTROPY ;
 
     /* This implementation is for test purposes only!
      * Use the libc non-cryptographic random generator. */
     mbedtls_test_rnd_std_rand( NULL, output, output_size );
     *output_length = output_size;
-    return( PSA_SUCCESS );
+    return PSA_SUCCESS ;
 }
 #endif /* MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
diff --git a/tests/src/helpers.c b/tests/src/helpers.c
index 4d3d53d..7bbfa50 100644
--- a/tests/src/helpers.c
+++ b/tests/src/helpers.c
@@ -37,7 +37,7 @@
 #if defined(MBEDTLS_PLATFORM_C)
     ret = mbedtls_platform_setup( &platform_ctx );
 #endif /* MBEDTLS_PLATFORM_C */
-    return( ret );
+    return ret ;
 }
 
 void mbedtls_test_platform_teardown( void )
@@ -56,9 +56,9 @@
     else if( ( c >= 'A' ) && ( c <= 'F' ) )
         *uc = c - 'A' + 10;
     else
-        return( -1 );
+        return -1 ;
 
-    return( 0 );
+    return 0 ;
 }
 
 void mbedtls_test_fail( const char *test, int line_no, const char* filename )
@@ -108,24 +108,24 @@
 
     /* Must be even number of bytes. */
     if ( ( *len ) & 1 )
-        return( -1 );
+        return -1 ;
     *len /= 2;
 
     if ( (*len) > obufmax )
-        return( -1 );
+        return -1 ;
 
     while( *ibuf != 0 )
     {
         if ( ascii2uc( *(ibuf++), &uc ) != 0 )
-            return( -1 );
+            return -1 ;
 
         if ( ascii2uc( *(ibuf++), &uc2 ) != 0 )
-            return( -1 );
+            return -1 ;
 
         *(obuf++) = ( uc << 4 ) | uc2;
     }
 
-    return( 0 );
+    return 0 ;
 }
 
 void mbedtls_test_hexify( unsigned char *obuf,
@@ -164,7 +164,7 @@
 
     memset( p, 0x00, actual_len );
 
-    return( p );
+    return p ;
 }
 
 unsigned char *mbedtls_test_unhexify_alloc( const char *ibuf, size_t *olen )
@@ -175,13 +175,13 @@
     *olen = strlen( ibuf ) / 2;
 
     if( *olen == 0 )
-        return( mbedtls_test_zero_alloc( *olen ) );
+        return mbedtls_test_zero_alloc( *olen ) ;
 
     obuf = mbedtls_calloc( 1, *olen );
     TEST_HELPER_ASSERT( obuf != NULL );
     TEST_HELPER_ASSERT( mbedtls_test_unhexify( obuf, *olen, ibuf, &len ) == 0 );
 
-    return( obuf );
+    return obuf ;
 }
 
 int mbedtls_test_hexcmp( uint8_t * a, uint8_t * b,
@@ -191,7 +191,7 @@
     uint32_t i = 0;
 
     if( a_len != b_len )
-        return( -1 );
+        return -1 ;
 
     for( i = 0; i < a_len; i++ )
     {
@@ -268,9 +268,9 @@
     if( s[0] == 0 )
     {
         mbedtls_mpi_free( X );
-        return( 0 );
+        return 0 ;
     }
     else
-        return( mbedtls_mpi_read_string( X, radix, s ) );
+        return mbedtls_mpi_read_string( X, radix, s ) ;
 }
 #endif
diff --git a/tests/src/psa_crypto_helpers.c b/tests/src/psa_crypto_helpers.c
index d9d841a..cef4093 100644
--- a/tests/src/psa_crypto_helpers.c
+++ b/tests/src/psa_crypto_helpers.c
@@ -42,18 +42,18 @@
         PSA_MAX_PERSISTENT_KEY_IDENTIFIER )
     {
         /* Don't touch key id values that designate non-key files. */
-        return( 1 );
+        return 1 ;
     }
     for( i = 0; i < num_key_ids_used ; i++ )
     {
         if( mbedtls_svc_key_id_equal( key_id, key_ids_used_in_test[i] ) )
-            return( 1 );
+            return 1 ;
     }
     if( num_key_ids_used == ARRAY_LENGTH( key_ids_used_in_test ) )
-        return( 0 );
+        return 0 ;
     key_ids_used_in_test[num_key_ids_used] = key_id;
     ++num_key_ids_used;
-    return( 1 );
+    return 1 ;
 }
 
 void mbedtls_test_psa_purge_key_storage( void )
@@ -80,17 +80,17 @@
     mbedtls_psa_get_stats( &stats );
 
     if( stats.volatile_slots != 0 )
-        return( "A volatile slot has not been closed properly." );
+        return "A volatile slot has not been closed properly." ;
     if( stats.persistent_slots != 0 )
-        return( "A persistent slot has not been closed properly." );
+        return "A persistent slot has not been closed properly." ;
     if( stats.external_slots != 0 )
-        return( "An external slot has not been closed properly." );
+        return "An external slot has not been closed properly." ;
      if( stats.half_filled_slots != 0 )
-        return( "A half-filled slot has not been cleared properly." );
+        return "A half-filled slot has not been cleared properly." ;
     if( stats.locked_slots != 0 )
-        return( "Some slots are still marked as locked." );
+        return "Some slots are still marked as locked." ;
 
-    return( NULL );
+    return NULL ;
 }
 
 #if defined(RECORD_PSA_STATUS_COVERAGE_LOG)
@@ -110,7 +110,7 @@
     if( log == NULL )
         log = fopen( STATUS_LOG_FILE_NAME, "a" );
     fprintf( log, "%d:%s:%s:%d:%s\n", (int) status, func, file, line, expr );
-    return( status );
+    return status ;
 }
 #endif /* defined(RECORD_PSA_STATUS_COVERAGE_LOG) */
 
@@ -124,7 +124,7 @@
     if( usage_flags & PSA_KEY_USAGE_VERIFY_HASH )
         updated_usage |= PSA_KEY_USAGE_VERIFY_MESSAGE;
 
-    return( updated_usage );
+    return updated_usage ;
 }
 
 #endif /* MBEDTLS_PSA_CRYPTO_C */
diff --git a/tests/src/psa_exercise_key.c b/tests/src/psa_exercise_key.c
index e4e55c9..f47f15a 100644
--- a/tests/src/psa_exercise_key.c
+++ b/tests/src/psa_exercise_key.c
@@ -110,7 +110,7 @@
      */
     psa_reset_key_attributes( &attributes );
 
-    return( ok );
+    return ok ;
 }
 
 static int exercise_mac_key( mbedtls_svc_key_id_t key,
@@ -151,11 +151,11 @@
                     verify_status );
     }
 
-    return( 1 );
+    return 1 ;
 
 exit:
     psa_mac_abort( &operation );
-    return( 0 );
+    return 0 ;
 }
 
 static int exercise_cipher_key( mbedtls_svc_key_id_t key,
@@ -224,11 +224,11 @@
             PSA_ASSERT( status );
     }
 
-    return( 1 );
+    return 1 ;
 
 exit:
     psa_cipher_abort( &operation );
-    return( 0 );
+    return 0 ;
 }
 
 static int exercise_aead_key( mbedtls_svc_key_id_t key,
@@ -287,10 +287,10 @@
                     verify_status );
     }
 
-    return( 1 );
+    return 1 ;
 
 exit:
-    return( 0 );
+    return 0 ;
 }
 
 static int exercise_signature_key( mbedtls_svc_key_id_t key,
@@ -371,10 +371,10 @@
         }
     }
 
-    return( 1 );
+    return 1 ;
 
 exit:
-    return( 0 );
+    return 0 ;
 }
 
 static int exercise_asymmetric_encryption_key( mbedtls_svc_key_id_t key,
@@ -409,10 +409,10 @@
                          status == PSA_ERROR_INVALID_PADDING ) ) );
     }
 
-    return( 1 );
+    return 1 ;
 
 exit:
-    return( 0 );
+    return 0 ;
 }
 
 int mbedtls_test_psa_setup_key_derivation_wrap(
@@ -458,10 +458,10 @@
     if( capacity != SIZE_MAX )
         PSA_ASSERT( psa_key_derivation_set_capacity( operation, capacity ) );
 
-    return( 1 );
+    return 1 ;
 
 exit:
-    return( 0 );
+    return 0 ;
 }
 
 
@@ -491,10 +491,10 @@
         PSA_ASSERT( psa_key_derivation_abort( &operation ) );
     }
 
-    return( 1 );
+    return 1 ;
 
 exit:
-    return( 0 );
+    return 0 ;
 }
 
 /* We need two keys to exercise key agreement. Exercise the
@@ -534,7 +534,7 @@
     psa_reset_key_attributes( &attributes );
 
     mbedtls_free( public_key );
-    return( status );
+    return status ;
 }
 
 /* We need two keys to exercise key agreement. Exercise the
@@ -586,7 +586,7 @@
     psa_reset_key_attributes( &attributes );
 
     mbedtls_free( public_key );
-    return( status );
+    return status ;
 }
 
 static int exercise_raw_key_agreement_key( mbedtls_svc_key_id_t key,
@@ -604,7 +604,7 @@
     ok = 1;
 
 exit:
-    return( ok );
+    return ok ;
 }
 
 static int exercise_key_agreement_key( mbedtls_svc_key_id_t key,
@@ -629,7 +629,7 @@
     ok = 1;
 
 exit:
-    return( ok );
+    return ok ;
 }
 
 int mbedtls_test_psa_exported_key_sanity_check(
@@ -785,10 +785,10 @@
     }
 #endif
 
-    return( 1 );
+    return 1 ;
 
 exit:
-    return( 0 );
+    return 0 ;
 }
 
 static int exercise_export_key( mbedtls_svc_key_id_t key,
@@ -832,7 +832,7 @@
     psa_reset_key_attributes( &attributes );
 
     mbedtls_free( exported );
-    return( ok );
+    return ok ;
 }
 
 static int exercise_export_public_key( mbedtls_svc_key_id_t key )
@@ -880,7 +880,7 @@
     psa_reset_key_attributes( &attributes );
 
     mbedtls_free( exported );
-    return( ok );
+    return ok ;
 }
 
 int mbedtls_test_psa_exercise_key( mbedtls_svc_key_id_t key,
@@ -890,7 +890,7 @@
     int ok = 0;
 
     if( ! check_key_attributes_sanity( key ) )
-        return( 0 );
+        return 0 ;
 
     if( alg == 0 )
         ok = 1; /* If no algorihm, do nothing (used for raw data "keys"). */
@@ -917,7 +917,7 @@
     ok = ok && exercise_export_public_key( key );
 
 exit:
-    return( ok );
+    return ok ;
 }
 
 psa_key_usage_t mbedtls_test_psa_usage_to_exercise( psa_key_type_t type,
@@ -952,11 +952,11 @@
     else if( PSA_ALG_IS_KEY_DERIVATION( alg ) ||
              PSA_ALG_IS_KEY_AGREEMENT( alg ) )
     {
-        return( PSA_KEY_USAGE_DERIVE );
+        return PSA_KEY_USAGE_DERIVE ;
     }
     else
     {
-        return( 0 );
+        return 0 ;
     }
 
 }
diff --git a/tests/src/random.c b/tests/src/random.c
index 7f3f401..d578985 100644
--- a/tests/src/random.c
+++ b/tests/src/random.c
@@ -56,7 +56,7 @@
     arc4random_buf( output, len );
 #endif /* !OpenBSD && !NetBSD */
 
-    return( 0 );
+    return 0 ;
 }
 
 int mbedtls_test_rnd_zero_rand( void *rng_state,
@@ -68,7 +68,7 @@
 
     memset( output, 0, len );
 
-    return( 0 );
+    return 0 ;
 }
 
 int mbedtls_test_rnd_buffer_rand( void *rng_state,
@@ -79,7 +79,7 @@
     size_t use_len;
 
     if( rng_state == NULL )
-        return( mbedtls_test_rnd_std_rand( NULL, output, len ) );
+        return mbedtls_test_rnd_std_rand( NULL, output, len ) ;
 
     use_len = len;
     if( len > info->length )
@@ -101,10 +101,10 @@
                                           len - use_len ) );
         }
         else
-            return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+            return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ;
     }
 
-    return( 0 );
+    return 0 ;
 }
 
 int mbedtls_test_rnd_pseudo_rand( void *rng_state,
@@ -117,7 +117,7 @@
     unsigned char result[4], *out = output;
 
     if( rng_state == NULL )
-        return( mbedtls_test_rnd_std_rand( NULL, output, len ) );
+        return mbedtls_test_rnd_std_rand( NULL, output, len ) ;
 
     k = info->key;
 
@@ -141,5 +141,5 @@
         out += 4;
     }
 
-    return( 0 );
+    return 0 ;
 }
diff --git a/tests/src/threading_helpers.c b/tests/src/threading_helpers.c
index ca91b79..f5a9564 100644
--- a/tests/src/threading_helpers.c
+++ b/tests/src/threading_helpers.c
@@ -160,7 +160,7 @@
             mbedtls_test_mutex_usage_error( mutex, "corrupted state" );
             break;
     }
-    return( ret );
+    return ret ;
 }
 
 static int mbedtls_test_wrap_mutex_unlock( mbedtls_threading_mutex_t *mutex )
@@ -182,7 +182,7 @@
             mbedtls_test_mutex_usage_error( mutex, "corrupted state" );
             break;
     }
-    return( ret );
+    return ret ;
 }
 
 void mbedtls_test_mutex_usage_init( void )