Skip to content

Commit fe11b72

Browse files
gilles-peskine-armgilles-peskine-arm
committed
Use TEST_EQUAL(a,b) in preference to TEST_ASSERT(a==b)
This commit is the result of the following command, followed by reindenting (but not wrapping lines): perl -00 -i -pe 's/^( *)TEST_ASSERT\(([^;=]*)(?: |\n *)==([^;=]*)\);$/${1}TEST_EQUAL($2,$3);/gm' tests/suites/test_suite_psa_*.function
1 parent 8817f61 commit fe11b72

7 files changed

+326
-326
lines changed

‎tests/suites/test_suite_psa_crypto.function

Lines changed: 203 additions & 203 deletions
Large diffs are not rendered by default.

‎tests/suites/test_suite_psa_crypto_entropy.function

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -52,9 +52,9 @@ void validate_entropy_seed_injection( int seed_length_a,
5252
TEST_ASSERT( ( its_status == PSA_ITS_SUCCESS ) ||
5353
( its_status == PSA_ITS_ERROR_KEY_NOT_FOUND ) );
5454
status = mbedtls_psa_inject_entropy( seed, seed_length_a );
55-
TEST_ASSERT( status == expected_status_a );
55+
TEST_EQUAL( status, expected_status_a );
5656
status = mbedtls_psa_inject_entropy( seed, seed_length_b );
57-
TEST_ASSERT( status == expected_status_b );
57+
TEST_EQUAL( status, expected_status_b );
5858
PSA_ASSERT( psa_crypto_init( ) );
5959
PSA_ASSERT( psa_generate_random( output,
6060
sizeof( output ) ) );
@@ -84,17 +84,17 @@ void run_entropy_inject_with_crypto_init( )
8484
status = mbedtls_psa_inject_entropy( seed, sizeof( seed ) );
8585
PSA_ASSERT( status );
8686
its_status = psa_its_remove( PSA_CRYPTO_ITS_RANDOM_SEED_UID );
87-
TEST_ASSERT( its_status == PSA_ITS_SUCCESS );
87+
TEST_EQUAL( its_status, PSA_ITS_SUCCESS );
8888
status = psa_crypto_init( );
89-
TEST_ASSERT( status == PSA_ERROR_INSUFFICIENT_ENTROPY );
89+
TEST_EQUAL( status, PSA_ERROR_INSUFFICIENT_ENTROPY );
9090
status = mbedtls_psa_inject_entropy( seed, sizeof( seed ) );
9191
PSA_ASSERT( status );
9292
status = psa_crypto_init( );
9393
PSA_ASSERT( status );
9494
mbedtls_psa_crypto_free( );
9595
/* The seed is written by nv_seed callback functions therefore the injection will fail */
9696
status = mbedtls_psa_inject_entropy( seed, sizeof( seed ) );
97-
TEST_ASSERT( status == PSA_ERROR_NOT_PERMITTED );
97+
TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
9898
exit:
9999
psa_its_remove( PSA_CRYPTO_ITS_RANDOM_SEED_UID );
100100
mbedtls_psa_crypto_free( );

‎tests/suites/test_suite_psa_crypto_init.function

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -176,7 +176,7 @@ void validate_module_init_generate_random( int count )
176176
mbedtls_psa_crypto_free( );
177177
}
178178
status = psa_generate_random( random, sizeof( random ) );
179-
TEST_ASSERT( status == PSA_ERROR_BAD_STATE );
179+
TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
180180
}
181181
/* END_CASE */
182182

@@ -193,7 +193,7 @@ void validate_module_init_key_based( int count )
193193
mbedtls_psa_crypto_free( );
194194
}
195195
status = psa_import_key( 1, PSA_KEY_TYPE_RAW_DATA, data, sizeof( data ) );
196-
TEST_ASSERT( status == PSA_ERROR_BAD_STATE );
196+
TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
197197
}
198198
/* END_CASE */
199199

@@ -207,7 +207,7 @@ void custom_entropy_sources( int sources_arg, int expected_init_status_arg )
207207
PSA_ASSERT( mbedtls_psa_crypto_configure_entropy_sources(
208208
custom_entropy_init, mbedtls_entropy_free ) );
209209

210-
TEST_ASSERT( psa_crypto_init( ) == expected_init_status );
210+
TEST_EQUAL( psa_crypto_init( ), expected_init_status );
211211
if( expected_init_status != PSA_SUCCESS )
212212
goto exit;
213213

@@ -247,7 +247,7 @@ void fake_entropy_source( int threshold,
247247
PSA_ASSERT( mbedtls_psa_crypto_configure_entropy_sources(
248248
custom_entropy_init, mbedtls_entropy_free ) );
249249

250-
TEST_ASSERT( psa_crypto_init( ) == expected_init_status );
250+
TEST_EQUAL( psa_crypto_init( ), expected_init_status );
251251
if( expected_init_status != PSA_SUCCESS )
252252
goto exit;
253253

@@ -274,7 +274,7 @@ void entropy_from_nv_seed( int seed_size_arg,
274274
PSA_ASSERT( mbedtls_psa_crypto_configure_entropy_sources(
275275
custom_entropy_init, mbedtls_entropy_free ) );
276276

277-
TEST_ASSERT( psa_crypto_init( ) == expected_init_status );
277+
TEST_EQUAL( psa_crypto_init( ), expected_init_status );
278278
if( expected_init_status != PSA_SUCCESS )
279279
goto exit;
280280

‎tests/suites/test_suite_psa_crypto_metadata.function

Lines changed: 50 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -83,15 +83,15 @@ void key_type_classification( psa_key_type_t type, unsigned flags )
8383
TEST_CLASSIFICATION_MACRO( KEY_TYPE_IS_ECC, type, flags );
8484

8585
/* Macros with derived semantics */
86-
TEST_ASSERT( PSA_KEY_TYPE_IS_ASYMMETRIC( type ) ==
87-
( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ||
88-
PSA_KEY_TYPE_IS_KEYPAIR( type ) ) );
89-
TEST_ASSERT( PSA_KEY_TYPE_IS_ECC_KEYPAIR( type ) ==
90-
( PSA_KEY_TYPE_IS_ECC( type ) &&
91-
PSA_KEY_TYPE_IS_KEYPAIR( type ) ) );
92-
TEST_ASSERT( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( type ) ==
93-
( PSA_KEY_TYPE_IS_ECC( type ) &&
94-
PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ) );
86+
TEST_EQUAL( PSA_KEY_TYPE_IS_ASYMMETRIC( type ),
87+
( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ||
88+
PSA_KEY_TYPE_IS_KEYPAIR( type ) ) );
89+
TEST_EQUAL( PSA_KEY_TYPE_IS_ECC_KEYPAIR( type ),
90+
( PSA_KEY_TYPE_IS_ECC( type ) &&
91+
PSA_KEY_TYPE_IS_KEYPAIR( type ) ) );
92+
TEST_EQUAL( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( type ),
93+
( PSA_KEY_TYPE_IS_ECC( type ) &&
94+
PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ) );
9595

9696
exit: ;
9797
}
@@ -113,7 +113,7 @@ void mac_algorithm_core( psa_algorithm_t alg, int classification_flags,
113113
algorithm_classification( alg, classification_flags );
114114

115115
/* Length */
116-
TEST_ASSERT( length == PSA_MAC_FINAL_SIZE( key_type, key_bits, alg ) );
116+
TEST_EQUAL( length, PSA_MAC_FINAL_SIZE( key_type, key_bits, alg ) );
117117

118118
exit: ;
119119
}
@@ -134,7 +134,7 @@ void aead_algorithm_core( psa_algorithm_t alg, int classification_flags,
134134
algorithm_classification( alg, classification_flags );
135135

136136
/* Tag length */
137-
TEST_ASSERT( tag_length == PSA_AEAD_TAG_LENGTH( alg ) );
137+
TEST_EQUAL( tag_length, PSA_AEAD_TAG_LENGTH( alg ) );
138138

139139
exit: ;
140140
}
@@ -174,18 +174,18 @@ void hash_algorithm( int alg_arg, int length_arg )
174174
algorithm_classification( alg, 0 );
175175

176176
/* Dependent algorithms */
177-
TEST_ASSERT( PSA_ALG_HMAC_GET_HASH( hmac_alg ) == alg );
178-
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( rsa_pkcs1v15_sign_alg ) == alg );
179-
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( rsa_pss_alg ) == alg );
180-
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( dsa_alg ) == alg );
181-
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( deterministic_dsa_alg ) == alg );
182-
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( ecdsa_alg ) == alg );
183-
TEST_ASSERT( PSA_ALG_SIGN_GET_HASH( deterministic_ecdsa_alg ) == alg );
184-
TEST_ASSERT( PSA_ALG_RSA_OAEP_GET_HASH( rsa_oaep_alg ) == alg );
185-
TEST_ASSERT( PSA_ALG_HKDF_GET_HASH( hkdf_alg ) == alg );
177+
TEST_EQUAL( PSA_ALG_HMAC_GET_HASH( hmac_alg ), alg );
178+
TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( rsa_pkcs1v15_sign_alg ), alg );
179+
TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( rsa_pss_alg ), alg );
180+
TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( dsa_alg ), alg );
181+
TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( deterministic_dsa_alg ), alg );
182+
TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( ecdsa_alg ), alg );
183+
TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( deterministic_ecdsa_alg ), alg );
184+
TEST_EQUAL( PSA_ALG_RSA_OAEP_GET_HASH( rsa_oaep_alg ), alg );
185+
TEST_EQUAL( PSA_ALG_HKDF_GET_HASH( hkdf_alg ), alg );
186186

187187
/* Hash length */
188-
TEST_ASSERT( length == PSA_HASH_SIZE( alg ) );
188+
TEST_EQUAL( length, PSA_HASH_SIZE( alg ) );
189189
TEST_ASSERT( length <= PSA_HASH_MAX_SIZE );
190190
}
191191
/* END_CASE */
@@ -203,7 +203,7 @@ void mac_algorithm( int alg_arg, int classification_flags,
203203

204204
mac_algorithm_core( alg, classification_flags,
205205
key_type, key_bits, length );
206-
TEST_ASSERT( PSA_ALG_FULL_LENGTH_MAC( alg ) == alg );
206+
TEST_EQUAL( PSA_ALG_FULL_LENGTH_MAC( alg ), alg );
207207
TEST_ASSERT( length <= PSA_MAC_MAX_SIZE );
208208

209209
/* Truncated versions */
@@ -212,16 +212,16 @@ void mac_algorithm( int alg_arg, int classification_flags,
212212
psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC( alg, n );
213213
mac_algorithm_core( truncated_alg, classification_flags,
214214
key_type, key_bits, n );
215-
TEST_ASSERT( PSA_ALG_FULL_LENGTH_MAC( truncated_alg ) == alg );
215+
TEST_EQUAL( PSA_ALG_FULL_LENGTH_MAC( truncated_alg ), alg );
216216
/* Check that calling PSA_ALG_TRUNCATED_MAC twice gives the length
217217
* of the outer truncation (even if the outer length is smaller than
218218
* the inner length). */
219-
TEST_ASSERT( PSA_ALG_TRUNCATED_MAC( truncated_alg, 1 ) ==
220-
PSA_ALG_TRUNCATED_MAC( alg, 1 ) );
221-
TEST_ASSERT( PSA_ALG_TRUNCATED_MAC( truncated_alg, length - 1 ) ==
222-
PSA_ALG_TRUNCATED_MAC( alg, length - 1) );
223-
TEST_ASSERT( PSA_ALG_TRUNCATED_MAC( truncated_alg, length ) ==
224-
PSA_ALG_TRUNCATED_MAC( alg, length ) );
219+
TEST_EQUAL( PSA_ALG_TRUNCATED_MAC( truncated_alg, 1 ),
220+
PSA_ALG_TRUNCATED_MAC( alg, 1 ) );
221+
TEST_EQUAL( PSA_ALG_TRUNCATED_MAC( truncated_alg, length - 1 ),
222+
PSA_ALG_TRUNCATED_MAC( alg, length - 1) );
223+
TEST_EQUAL( PSA_ALG_TRUNCATED_MAC( truncated_alg, length ),
224+
PSA_ALG_TRUNCATED_MAC( alg, length ) );
225225
}
226226
}
227227
/* END_CASE */
@@ -238,7 +238,7 @@ void hmac_algorithm( int alg_arg,
238238
size_t n;
239239

240240
TEST_ASSERT( PSA_ALG_IS_HASH( hash_alg ) );
241-
TEST_ASSERT( PSA_ALG_HMAC( hash_alg ) == alg );
241+
TEST_EQUAL( PSA_ALG_HMAC( hash_alg ), alg );
242242

243243
TEST_ASSERT( block_size <= PSA_HMAC_MAX_HASH_BLOCK_SIZE );
244244

@@ -248,7 +248,7 @@ void hmac_algorithm( int alg_arg,
248248
for( n = 1; n <= length; n++ )
249249
{
250250
psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC( alg, n );
251-
TEST_ASSERT( PSA_ALG_HMAC_GET_HASH( truncated_alg ) == hash_alg );
251+
TEST_EQUAL( PSA_ALG_HMAC_GET_HASH( truncated_alg ), hash_alg );
252252
}
253253
}
254254
/* END_CASE */
@@ -287,19 +287,19 @@ void aead_algorithm( int alg_arg, int classification_flags,
287287
{
288288
psa_algorithm_t truncated_alg = PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, n );
289289
aead_algorithm_core( truncated_alg, classification_flags, n );
290-
TEST_ASSERT(
291-
PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH( truncated_alg ) == alg );
290+
TEST_EQUAL(
291+
PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH( truncated_alg ), alg );
292292
/* Check that calling PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH twice gives
293293
* the length of the outer truncation (even if the outer length is
294294
* smaller than the inner length). */
295-
TEST_ASSERT(
296-
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, 1 ) ==
295+
TEST_EQUAL(
296+
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, 1 ),
297297
PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, 1 ) );
298-
TEST_ASSERT(
299-
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, tag_length - 1 ) ==
298+
TEST_EQUAL(
299+
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, tag_length - 1 ),
300300
PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, tag_length - 1) );
301-
TEST_ASSERT(
302-
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, tag_length ) ==
301+
TEST_EQUAL(
302+
PSA_ALG_AEAD_WITH_TAG_LENGTH( truncated_alg, tag_length ),
303303
PSA_ALG_AEAD_WITH_TAG_LENGTH( alg, tag_length ) );
304304
}
305305
}
@@ -363,8 +363,8 @@ void key_derivation_algorithm( int alg_arg, int classification_flags )
363363
/* Check combinations with key agreements */
364364
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_FFDH( alg ) ) );
365365
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_ECDH( alg ) ) );
366-
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_ECDH( alg ) ) == alg );
367-
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_FFDH( alg ) ) == alg );
366+
TEST_EQUAL( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_ECDH( alg ) ), alg );
367+
TEST_EQUAL( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_FFDH( alg ) ), alg );
368368
}
369369
/* END_CASE */
370370

@@ -388,8 +388,8 @@ void key_selection_algorithm( int alg_arg, int classification_flags )
388388
/* Check combinations with key agreements */
389389
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_FFDH( alg ) ) );
390390
TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( PSA_ALG_ECDH( alg ) ) );
391-
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_ECDH( alg ) ) == alg );
392-
TEST_ASSERT( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_FFDH( alg ) ) == alg );
391+
TEST_EQUAL( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_ECDH( alg ) ), alg );
392+
TEST_EQUAL( PSA_ALG_KEY_AGREEMENT_GET_KDF( PSA_ALG_FFDH( alg ) ), alg );
393393
}
394394
/* END_CASE */
395395

@@ -416,7 +416,7 @@ void key_agreement_algorithm( int alg_arg, int classification_flags,
416416
/* Shared secret derivation properties */
417417
TEST_ASSERT( PSA_ALG_IS_KEY_DERIVATION( actual_post_alg ) ||
418418
PSA_ALG_IS_KEY_SELECTION( actual_post_alg ) );
419-
TEST_ASSERT( actual_post_alg == expected_post_alg );
419+
TEST_EQUAL( actual_post_alg, expected_post_alg );
420420
}
421421
/* END_CASE */
422422

@@ -431,22 +431,22 @@ void key_type( int type_arg, int classification_flags )
431431
if( classification_flags & KEY_TYPE_IS_PUBLIC_KEY )
432432
{
433433
psa_key_type_t pair_type = PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( type );
434-
TEST_ASSERT( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( pair_type ) == type );
434+
TEST_EQUAL( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( pair_type ), type );
435435
key_type_classification( pair_type,
436436
( classification_flags
437437
& ~KEY_TYPE_IS_PUBLIC_KEY )
438438
| KEY_TYPE_IS_KEYPAIR );
439-
TEST_ASSERT( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( type ) == type );
439+
TEST_EQUAL( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( type ), type );
440440
}
441441
if( classification_flags & KEY_TYPE_IS_KEYPAIR )
442442
{
443443
psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR( type );
444-
TEST_ASSERT( PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( public_type ) == type );
444+
TEST_EQUAL( PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( public_type ), type );
445445
key_type_classification( public_type,
446446
( classification_flags
447447
& ~KEY_TYPE_IS_KEYPAIR )
448448
| KEY_TYPE_IS_PUBLIC_KEY );
449-
TEST_ASSERT( PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( type ) == type );
449+
TEST_EQUAL( PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY( type ), type );
450450
}
451451
}
452452
/* END_CASE */
@@ -462,8 +462,8 @@ void ecc_key_types( int curve_arg, int curve_bits_arg )
462462
test_key_type( public_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_PUBLIC_KEY );
463463
test_key_type( pair_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_KEYPAIR );
464464

465-
TEST_ASSERT( PSA_KEY_TYPE_GET_CURVE( public_type ) == curve );
466-
TEST_ASSERT( PSA_KEY_TYPE_GET_CURVE( pair_type ) == curve );
465+
TEST_EQUAL( PSA_KEY_TYPE_GET_CURVE( public_type ), curve );
466+
TEST_EQUAL( PSA_KEY_TYPE_GET_CURVE( pair_type ), curve );
467467

468468
/* Validate that the bit size is less than the maximum ECC bit size
469469
* in this implementation. There's no parameter that should be equal

‎tests/suites/test_suite_psa_crypto_persistent_key.function

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -66,13 +66,13 @@ void parse_storage_data_check( data_t *file_data,
6666
&key_data, &key_data_length,
6767
&key_type, &key_policy );
6868

69-
TEST_ASSERT( status == expected_status );
69+
TEST_EQUAL( status, expected_status );
7070
if( status != PSA_SUCCESS )
7171
goto exit;
7272

73-
TEST_ASSERT( key_type == (psa_key_type_t) expected_key_type );
74-
TEST_ASSERT( key_policy.usage == (uint32_t) expected_key_usage );
75-
TEST_ASSERT( key_policy.alg == (uint32_t) expected_key_alg );
73+
TEST_EQUAL( key_type, (psa_key_type_t) expected_key_type );
74+
TEST_EQUAL( key_policy.usage, (uint32_t) expected_key_usage );
75+
TEST_EQUAL( key_policy.alg, (uint32_t) expected_key_alg );
7676
ASSERT_COMPARE( expected_key_data->x, expected_key_data->len,
7777
key_data, key_data_length );
7878

@@ -101,8 +101,8 @@ void save_large_persistent_key( int data_too_large, int expected_status )
101101
PSA_BYTES_TO_BITS( data_length ),
102102
&handle ) );
103103

104-
TEST_ASSERT( psa_import_key( handle, PSA_KEY_TYPE_RAW_DATA,
105-
data, data_length ) == expected_status );
104+
TEST_EQUAL( psa_import_key( handle, PSA_KEY_TYPE_RAW_DATA,
105+
data, data_length ), expected_status );
106106

107107
exit:
108108
mbedtls_free( data );
@@ -142,10 +142,10 @@ void persistent_key_destroy( int key_id_arg, int should_store,
142142
PSA_ASSERT( psa_destroy_key( handle ) );
143143

144144
/* Check key slot storage is removed */
145-
TEST_ASSERT( psa_is_key_present_in_storage( key_id ) == 0 );
146-
TEST_ASSERT( psa_open_key( PSA_KEY_LIFETIME_PERSISTENT, key_id,
147-
&handle ) == PSA_ERROR_EMPTY_SLOT );
148-
TEST_ASSERT( handle == 0 );
145+
TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 0 );
146+
TEST_EQUAL( psa_open_key( PSA_KEY_LIFETIME_PERSISTENT, key_id,
147+
&handle ), PSA_ERROR_EMPTY_SLOT );
148+
TEST_EQUAL( handle, 0 );
149149

150150
/* Shutdown and restart */
151151
mbedtls_psa_crypto_free();
@@ -183,17 +183,17 @@ void persistent_key_import( int key_id_arg, int type_arg, data_t *data,
183183
PSA_BYTES_TO_BITS( data->len ),
184184
&handle ) );
185185
psa_key_policy_init( &policy );
186-
TEST_ASSERT( psa_import_key( handle, type,
187-
data->x, data->len ) == expected_status );
186+
TEST_EQUAL( psa_import_key( handle, type,
187+
data->x, data->len ), expected_status );
188188

189189
if( expected_status != PSA_SUCCESS )
190190
{
191-
TEST_ASSERT( psa_is_key_present_in_storage( key_id ) == 0 );
191+
TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 0 );
192192
goto exit;
193193
}
194194

195195
PSA_ASSERT( psa_get_key_lifetime( handle, &lifetime ) );
196-
TEST_ASSERT( lifetime == PSA_KEY_LIFETIME_PERSISTENT );
196+
TEST_EQUAL( lifetime, PSA_KEY_LIFETIME_PERSISTENT );
197197

198198
exit:
199199
psa_destroy_persistent_key( key_id );
@@ -235,15 +235,15 @@ void import_export_persistent_key( data_t *data, int type_arg,
235235
data->x, data->len ) );
236236

237237
PSA_ASSERT( psa_get_key_lifetime( handle, &lifetime_get ) );
238-
TEST_ASSERT( lifetime_get == PSA_KEY_LIFETIME_PERSISTENT );
238+
TEST_EQUAL( lifetime_get, PSA_KEY_LIFETIME_PERSISTENT );
239239

240240
/* Test the key information */
241241
PSA_ASSERT( psa_get_key_information(
242242
handle, &got_type, &got_bits ) );
243-
TEST_ASSERT( got_type == type );
244-
TEST_ASSERT( got_bits == (size_t) expected_bits );
243+
TEST_EQUAL( got_type, type );
244+
TEST_EQUAL( got_bits, (size_t) expected_bits );
245245

246-
TEST_ASSERT( psa_is_key_present_in_storage( key_id ) == 1 );
246+
TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 1 );
247247

248248
if( key_not_exist )
249249
{
@@ -257,7 +257,7 @@ void import_export_persistent_key( data_t *data, int type_arg,
257257

258258
/* Destroy the key */
259259
PSA_ASSERT( psa_destroy_key( handle ) );
260-
TEST_ASSERT( psa_is_key_present_in_storage( key_id ) == 0 );
260+
TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 0 );
261261

262262
exit:
263263
mbedtls_free( exported );

0 commit comments

Comments
 (0)