lib/mbedtls
1
0
Fork 0
mirror of https://github.com/Mbed-TLS/mbedtls.git synced 2025-07-30 22:43:08 +03:00
Code Activity

Merge pull request #8838 from paul-elliott-arm/improve_test_data_accessors

Browse Source 
Improve test info data accessors
This commit is contained in:
Tom Cosgrove
2024-02-26 11:22:20 +00:00
committed by GitHub
parent 0f63028809 9011dae0c1
commit f4a200f106
2 changed files with 61 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
tests/src/helpers.c
View File

@ -31,7 +31,16 @@ mbedtls_threading_mutex_t mbedtls_test_info_mutex;
#endif /* MBEDTLS_THREADING_C */ #endif /* MBEDTLS_THREADING_C */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Mbedtls Test Info accessors */ /* Mbedtls Test Info accessors
*
* NOTE - there are two types of accessors here: public accessors and internal
* accessors. The public accessors have prototypes in helpers.h and lock
* mbedtls_test_info_mutex (if mutexes are enabled). The _internal accessors,
* which are expected to be used from this module *only*, do not lock the mutex.
* These are designed to be called from within public functions which already
* hold the mutex. The main reason for this difference is the need to set
* multiple test data values atomically (without releasing the mutex) to prevent
* race conditions. */
mbedtls_test_result_t mbedtls_test_get_result(void) mbedtls_test_result_t mbedtls_test_get_result(void)
{ {
@ -50,8 +59,8 @@ mbedtls_test_result_t mbedtls_test_get_result(void)
return result; return result;
} }
void mbedtls_test_set_result(mbedtls_test_result_t result, const char *test, static void mbedtls_test_set_result_internal(mbedtls_test_result_t result, const char *test,
int line_no, const char *filename) int line_no, const char *filename)
{ {
/* Internal function only - mbedtls_test_info_mutex should be held prior /* Internal function only - mbedtls_test_info_mutex should be held prior
* to calling this function. */ * to calling this function. */
@ -144,7 +153,7 @@ unsigned long mbedtls_test_get_step(void)
return step; return step;
} }
void mbedtls_test_reset_step(void) static void mbedtls_test_reset_step_internal(void)
{ {
/* Internal function only - mbedtls_test_info_mutex should be held prior /* Internal function only - mbedtls_test_info_mutex should be held prior
* to calling this function. */ * to calling this function. */
@ -178,7 +187,7 @@ void mbedtls_test_get_line1(char *line)
#endif /* MBEDTLS_THREADING_C */ #endif /* MBEDTLS_THREADING_C */
} }
void mbedtls_test_set_line1(const char *line) static void mbedtls_test_set_line1_internal(const char *line)
{ {
/* Internal function only - mbedtls_test_info_mutex should be held prior /* Internal function only - mbedtls_test_info_mutex should be held prior
* to calling this function. */ * to calling this function. */
@ -203,7 +212,7 @@ void mbedtls_test_get_line2(char *line)
#endif /* MBEDTLS_THREADING_C */ #endif /* MBEDTLS_THREADING_C */
} }
void mbedtls_test_set_line2(const char *line) static void mbedtls_test_set_line2_internal(const char *line)
{ {
/* Internal function only - mbedtls_test_info_mutex should be held prior /* Internal function only - mbedtls_test_info_mutex should be held prior
* to calling this function. */ * to calling this function. */
@ -219,7 +228,19 @@ void mbedtls_test_set_line2(const char *line)
#if defined(MBEDTLS_TEST_MUTEX_USAGE) #if defined(MBEDTLS_TEST_MUTEX_USAGE)
const char *mbedtls_test_get_mutex_usage_error(void) const char *mbedtls_test_get_mutex_usage_error(void)
{ {
return mbedtls_test_info.mutex_usage_error; const char *usage_error;
#ifdef MBEDTLS_THREADING_C
mbedtls_mutex_lock(&mbedtls_test_info_mutex);
#endif /* MBEDTLS_THREADING_C */
usage_error = mbedtls_test_info.mutex_usage_error;
#ifdef MBEDTLS_THREADING_C
mbedtls_mutex_unlock(&mbedtls_test_info_mutex);
#endif /* MBEDTLS_THREADING_C */
return usage_error;
} }
void mbedtls_test_set_mutex_usage_error(const char *msg) void mbedtls_test_set_mutex_usage_error(const char *msg)
@ -255,7 +276,7 @@ unsigned mbedtls_test_get_case_uses_negative_0(void)
return test_case_uses_negative_0; return test_case_uses_negative_0;
} }
void mbedtls_test_set_case_uses_negative_0(unsigned uses) static void mbedtls_test_set_case_uses_negative_0_internal(unsigned uses)
{ {
/* Internal function only - mbedtls_test_info_mutex should be held prior /* Internal function only - mbedtls_test_info_mutex should be held prior
* to calling this function. */ * to calling this function. */
@ -350,7 +371,7 @@ static void mbedtls_test_fail_internal(const char *test, int line_no, const char
if (mbedtls_test_info.result != MBEDTLS_TEST_RESULT_FAILED) { if (mbedtls_test_info.result != MBEDTLS_TEST_RESULT_FAILED) {
/* If we have already recorded the test as having failed then don't /* If we have already recorded the test as having failed then don't
* overwrite any previous information about the failure. */ * overwrite any previous information about the failure. */
mbedtls_test_set_result(MBEDTLS_TEST_RESULT_FAILED, test, line_no, filename); mbedtls_test_set_result_internal(MBEDTLS_TEST_RESULT_FAILED, test, line_no, filename);
} }
} }
@ -373,7 +394,7 @@ void mbedtls_test_skip(const char *test, int line_no, const char *filename)
mbedtls_mutex_lock(&mbedtls_test_info_mutex); mbedtls_mutex_lock(&mbedtls_test_info_mutex);
#endif /* MBEDTLS_THREADING_C */ #endif /* MBEDTLS_THREADING_C */
mbedtls_test_set_result(MBEDTLS_TEST_RESULT_SKIPPED, test, line_no, filename); mbedtls_test_set_result_internal(MBEDTLS_TEST_RESULT_SKIPPED, test, line_no, filename);
#ifdef MBEDTLS_THREADING_C #ifdef MBEDTLS_THREADING_C
mbedtls_mutex_unlock(&mbedtls_test_info_mutex); mbedtls_mutex_unlock(&mbedtls_test_info_mutex);
@ -386,13 +407,13 @@ void mbedtls_test_info_reset(void)
mbedtls_mutex_lock(&mbedtls_test_info_mutex); mbedtls_mutex_lock(&mbedtls_test_info_mutex);
#endif /* MBEDTLS_THREADING_C */ #endif /* MBEDTLS_THREADING_C */
mbedtls_test_set_result(MBEDTLS_TEST_RESULT_SUCCESS, 0, 0, 0); mbedtls_test_set_result_internal(MBEDTLS_TEST_RESULT_SUCCESS, 0, 0, 0);
mbedtls_test_reset_step(); mbedtls_test_reset_step_internal();
mbedtls_test_set_line1(NULL); mbedtls_test_set_line1_internal(NULL);
mbedtls_test_set_line2(NULL); mbedtls_test_set_line2_internal(NULL);
#if defined(MBEDTLS_BIGNUM_C) #if defined(MBEDTLS_BIGNUM_C)
mbedtls_test_set_case_uses_negative_0(0); mbedtls_test_set_case_uses_negative_0_internal(0);
#endif #endif
#ifdef MBEDTLS_THREADING_C #ifdef MBEDTLS_THREADING_C
@ -424,11 +445,11 @@ int mbedtls_test_equal(const char *test, int line_no, const char *filename,
(void) mbedtls_snprintf(buf, sizeof(buf), (void) mbedtls_snprintf(buf, sizeof(buf),
"lhs = 0x%016llx = %lld", "lhs = 0x%016llx = %lld",
value1, (long long) value1); value1, (long long) value1);
mbedtls_test_set_line1(buf); mbedtls_test_set_line1_internal(buf);
(void) mbedtls_snprintf(buf, sizeof(buf), (void) mbedtls_snprintf(buf, sizeof(buf),
"rhs = 0x%016llx = %lld", "rhs = 0x%016llx = %lld",
value2, (long long) value2); value2, (long long) value2);
mbedtls_test_set_line2(buf); mbedtls_test_set_line2_internal(buf);
} }
#ifdef MBEDTLS_THREADING_C #ifdef MBEDTLS_THREADING_C
@ -462,11 +483,11 @@ int mbedtls_test_le_u(const char *test, int line_no, const char *filename,
(void) mbedtls_snprintf(buf, sizeof(buf), (void) mbedtls_snprintf(buf, sizeof(buf),
"lhs = 0x%016llx = %llu", "lhs = 0x%016llx = %llu",
value1, value1); value1, value1);
mbedtls_test_set_line1(buf); mbedtls_test_set_line1_internal(buf);
(void) mbedtls_snprintf(buf, sizeof(buf), (void) mbedtls_snprintf(buf, sizeof(buf),
"rhs = 0x%016llx = %llu", "rhs = 0x%016llx = %llu",
value2, value2); value2, value2);
mbedtls_test_set_line2(buf); mbedtls_test_set_line2_internal(buf);
} }
#ifdef MBEDTLS_THREADING_C #ifdef MBEDTLS_THREADING_C
@ -500,11 +521,11 @@ int mbedtls_test_le_s(const char *test, int line_no, const char *filename,
(void) mbedtls_snprintf(buf, sizeof(buf), (void) mbedtls_snprintf(buf, sizeof(buf),
"lhs = 0x%016llx = %lld", "lhs = 0x%016llx = %lld",
(unsigned long long) value1, value1); (unsigned long long) value1, value1);
mbedtls_test_set_line1(buf); mbedtls_test_set_line1_internal(buf);
(void) mbedtls_snprintf(buf, sizeof(buf), (void) mbedtls_snprintf(buf, sizeof(buf),
"rhs = 0x%016llx = %lld", "rhs = 0x%016llx = %lld",
(unsigned long long) value2, value2); (unsigned long long) value2, value2);
mbedtls_test_set_line2(buf); mbedtls_test_set_line2_internal(buf);
} }
#ifdef MBEDTLS_THREADING_C #ifdef MBEDTLS_THREADING_C

34
tests/src/threading_helpers.c
View File

@ -317,22 +317,26 @@ void mbedtls_test_mutex_usage_init(void)
void mbedtls_test_mutex_usage_check(void) void mbedtls_test_mutex_usage_check(void)
{ {
if (live_mutexes != 0) { if (mutex_functions.lock(&mbedtls_test_mutex_mutex) == 0) {
/* A positive number (more init than free) means that a mutex resource if (live_mutexes != 0) {
* is leaking (on platforms where a mutex consumes more than the /* A positive number (more init than free) means that a mutex resource
* mbedtls_threading_mutex_t object itself). The rare case of a * is leaking (on platforms where a mutex consumes more than the
* negative number means a missing init somewhere. */ * mbedtls_threading_mutex_t object itself). The (hopefully) rare
mbedtls_fprintf(stdout, "[mutex: %d leaked] ", live_mutexes); * case of a negative number means a missing init somewhere. */
live_mutexes = 0; mbedtls_fprintf(stdout, "[mutex: %d leaked] ", live_mutexes);
mbedtls_test_set_mutex_usage_error("missing free"); live_mutexes = 0;
mbedtls_test_set_mutex_usage_error("missing free");
}
if (mbedtls_test_get_mutex_usage_error() != NULL &&
mbedtls_test_get_result() != MBEDTLS_TEST_RESULT_FAILED) {
/* Functionally, the test passed. But there was a mutex usage error,
* so mark the test as failed after all. */
mbedtls_test_fail("Mutex usage error", __LINE__, __FILE__);
}
mbedtls_test_set_mutex_usage_error(NULL);
mutex_functions.unlock(&mbedtls_test_mutex_mutex);
} }
if (mbedtls_test_get_mutex_usage_error() != NULL &&
mbedtls_test_get_result() != MBEDTLS_TEST_RESULT_FAILED) {
/* Functionally, the test passed. But there was a mutex usage error,
* so mark the test as failed after all. */
mbedtls_test_fail("Mutex usage error", __LINE__, __FILE__);
}
mbedtls_test_set_mutex_usage_error(NULL);
} }
void mbedtls_test_mutex_usage_end(void) void mbedtls_test_mutex_usage_end(void)