crypto_se_driver: rename ram_ tests to mock_ tests

Author: AndrzejKurek

tests/suites/test_suite_psa_crypto_se_driver_hal.data

@@ -34,4 +34,4 @@ Key creation smoke test (p_allocate allows all slots)
 key_creation_import_export:0
 
 Key creation smoke test (p_allocate allows 1 slot)
-key_creation_import_export:ARRAY_LENGTH( ram_slots ) - 1
+key_creation_import_export:ARRAY_LENGTH( mock_slots ) - 1

tests/suites/test_suite_psa_crypto_se_driver_hal.function

@@ -11,76 +11,76 @@
  * This is probably a bug in the library. */
 #define PSA_ERROR_DETECTED_BY_DRIVER ((psa_status_t)( -500 ))
 
-#define RAM_MAX_KEY_SIZE 64
+#define MOCK_MAX_KEY_SIZE 64
 typedef struct
 {
     psa_key_lifetime_t lifetime;
     psa_key_type_t type;
     size_t bits;
-    uint8_t content[RAM_MAX_KEY_SIZE];
-} ram_slot_t;
-static ram_slot_t ram_slots[16];
+    uint8_t content[MOCK_MAX_KEY_SIZE];
+} mock_slot_t;
+static mock_slot_t mock_slots[16];
 
-static uint8_t ram_min_slot = 0;
+static uint8_t mock_min_slot = 0;
 
-static void ram_slots_reset( void )
+static void mock_slots_reset( void )
 {
-    memset( ram_slots, 0, sizeof( ram_slots ) );
-    ram_min_slot = 0;
+    memset( mock_slots, 0, sizeof( mock_slots ) );
+    mock_min_slot = 0;
 }
 
-static psa_status_t ram_import( psa_key_slot_number_t slot_number,
+static psa_status_t mock_import( psa_key_slot_number_t slot_number,
                                 psa_key_lifetime_t lifetime,
                                 psa_key_type_t type,
                                 psa_algorithm_t algorithm,
                                 psa_key_usage_t usage,
                                 const uint8_t *p_data,
                                 size_t data_length )
 {
-    if( slot_number > ARRAY_LENGTH( ram_slots ) )
+    if( slot_number > ARRAY_LENGTH( mock_slots ) )
         return( PSA_ERROR_DETECTED_BY_DRIVER );
-    if( data_length > sizeof( ram_slots[slot_number].content ) )
+    if( data_length > sizeof( mock_slots[slot_number].content ) )
         return( PSA_ERROR_INSUFFICIENT_STORAGE );
-    ram_slots[slot_number].lifetime = lifetime;
-    ram_slots[slot_number].type = type;
-    ram_slots[slot_number].bits = PSA_BYTES_TO_BITS( data_length );
+    mock_slots[slot_number].lifetime = lifetime;
+    mock_slots[slot_number].type = type;
+    mock_slots[slot_number].bits = PSA_BYTES_TO_BITS( data_length );
     (void) algorithm;
     (void) usage;
-    memcpy( ram_slots[slot_number].content, p_data, data_length );
+    memcpy( mock_slots[slot_number].content, p_data, data_length );
     return( PSA_SUCCESS );
 }
 
-psa_status_t ram_export( psa_key_slot_number_t slot_number,
+psa_status_t mock_export( psa_key_slot_number_t slot_number,
                          uint8_t *p_data,
                          size_t data_size,
                          size_t *p_data_length )
 {
     size_t actual_size;
-    if( slot_number > ARRAY_LENGTH( ram_slots ) )
+    if( slot_number > ARRAY_LENGTH( mock_slots ) )
         return( PSA_ERROR_DETECTED_BY_DRIVER );
-    actual_size = PSA_BITS_TO_BYTES( ram_slots[slot_number].bits );
+    actual_size = PSA_BITS_TO_BYTES( mock_slots[slot_number].bits );
     if( actual_size > data_size )
         return( PSA_ERROR_BUFFER_TOO_SMALL );
     *p_data_length = actual_size;
-    memcpy( p_data, ram_slots[slot_number].content, actual_size );
+    memcpy( p_data, mock_slots[slot_number].content, actual_size );
     return( PSA_SUCCESS );
 }
 
-psa_status_t ram_destroy( psa_key_slot_number_t slot_number )
+psa_status_t mock_destroy( psa_key_slot_number_t slot_number )
 {
-    if( slot_number > ARRAY_LENGTH( ram_slots ) )
+    if( slot_number > ARRAY_LENGTH( mock_slots ) )
         return( PSA_ERROR_DETECTED_BY_DRIVER );
-    memset( &ram_slots[slot_number], 0, sizeof( ram_slots[slot_number] ) );
+    memset( &mock_slots[slot_number], 0, sizeof( mock_slots[slot_number] ) );
     return( PSA_SUCCESS );
 }
 
-psa_status_t ram_allocate( const psa_key_attributes_t *attributes,
+psa_status_t mock_allocate( const psa_key_attributes_t *attributes,
                            const psa_drv_se_slot_usage_t *slot_usage,
                            psa_key_slot_number_t *slot_number )
 {
     (void) attributes;
     return( psa_drv_cb_find_free_slot( slot_usage,
-                                       ram_min_slot, -1,
+                                       mock_min_slot, -1,
                                        slot_number ) );
 }
 
@@ -174,14 +174,14 @@ void key_creation_import_export( int min_slot )
     memset( &key_management, 0, sizeof( key_management ) );
     driver.hal_version = PSA_DRV_SE_HAL_VERSION;
     driver.key_management = &key_management;
-    key_management.slot_count = ARRAY_LENGTH( ram_slots );
-    key_management.p_import = ram_import;
-    key_management.p_export = ram_export;
-    key_management.p_destroy = ram_destroy;
+    key_management.slot_count = ARRAY_LENGTH( mock_slots );
+    key_management.p_import = mock_import;
+    key_management.p_export = mock_export;
+    key_management.p_destroy = mock_destroy;
     if( min_slot >= 0 )
     {
-        key_management.p_allocate = ram_allocate;
-        ram_min_slot = min_slot;
+        key_management.p_allocate = mock_allocate;
+        mock_min_slot = min_slot;
     }
 
     PSA_ASSERT( psa_register_se_driver( lifetime, &driver ) );
@@ -196,7 +196,7 @@ void key_creation_import_export( int min_slot )
                                 &handle ) );
 
     /* Test that the key was created in the designated slot. */
-    TEST_ASSERT( ram_slots[expected_slot].type == PSA_KEY_TYPE_RAW_DATA );
+    TEST_ASSERT( mock_slots[expected_slot].type == PSA_KEY_TYPE_RAW_DATA );
 
     PSA_ASSERT( psa_export_key( handle,
                                 exported, sizeof( exported ),
@@ -207,10 +207,10 @@ void key_creation_import_export( int min_slot )
     PSA_ASSERT( psa_destroy_key( handle ) );
 
     /* Test that the key has been erased from the designated slot. */
-    TEST_ASSERT( ram_slots[expected_slot].type == 0 );
+    TEST_ASSERT( mock_slots[expected_slot].type == 0 );
 
 exit:
     PSA_DONE( );
-    ram_slots_reset( );
+    mock_slots_reset( );
 }
 /* END_CASE */