From 340d5db44872feeca8c29e970e6091f057a76aca Mon Sep 17 00:00:00 2001 From: Kevin Day Date: Sun, 2 Nov 2025 16:03:15 -0600 Subject: [PATCH] Update: Provide more granular error status codes in the thread full functions. The LIBC pthread implementations fail to provide a way to truly verify that thread data is properly allocated or not. The full thread types have two different thread related memory freeing functions. If the first function fails, then the second structure is still allocated. The previous behavior provided no way to distinguish between the two different failures. These more granular status codes allow for such distinction now. This allows the caller to manually try to de-allocate other parts even if the first de-allocation failed. --- level_0/f_thread/c/thread/barrier_full.c | 4 ++-- level_0/f_thread/c/thread/barrier_full.h | 9 +++++--- level_0/f_thread/c/thread/barrier_fulls.c | 8 ++++---- level_0/f_thread/c/thread/barrier_fulls.h | 22 ++++++++++++++------ level_0/f_thread/c/thread/barrier_fullss.c | 8 ++++---- level_0/f_thread/c/thread/barrier_fullss.h | 24 ++++++++++++++++------ level_0/f_thread/c/thread/condition_full.c | 4 ++-- level_0/f_thread/c/thread/condition_full.h | 9 +++++--- level_0/f_thread/c/thread/condition_fulls.c | 8 ++++---- level_0/f_thread/c/thread/condition_fulls.h | 24 ++++++++++++++++------ level_0/f_thread/c/thread/condition_fullss.c | 8 ++++---- level_0/f_thread/c/thread/condition_fullss.h | 24 ++++++++++++++++------ level_0/f_thread/c/thread/lock_full.c | 4 ++-- level_0/f_thread/c/thread/lock_full.h | 9 +++++++- level_0/f_thread/c/thread/lock_fulls.c | 8 ++++---- level_0/f_thread/c/thread/lock_fulls.h | 20 ++++++++++++------ level_0/f_thread/c/thread/lock_fullss.c | 8 ++++---- level_0/f_thread/c/thread/lock_fullss.h | 20 ++++++++++++------ level_0/f_thread/c/thread/mutex_full.c | 4 ++-- level_0/f_thread/c/thread/mutex_full.h | 9 +++++--- level_0/f_thread/c/thread/mutex_fulls.c | 8 ++++---- level_0/f_thread/c/thread/mutex_fulls.h | 24 ++++++++++++++++------ level_0/f_thread/c/thread/mutex_fullss.c | 8 ++++---- level_0/f_thread/c/thread/mutex_fullss.h | 24 ++++++++++++++++------ .../tests/unit/c/test-thread-barrier_full_delete.c | 14 +++++++++---- .../c/test-thread-barrier_fulls_delete_callback.c | 14 +++++++++---- .../c/test-thread-barrier_fulls_destroy_callback.c | 14 +++++++++---- .../c/test-thread-barrier_fullss_delete_callback.c | 14 +++++++++---- .../test-thread-barrier_fullss_destroy_callback.c | 14 +++++++++---- .../unit/c/test-thread-condition_full_delete.c | 14 +++++++++---- .../test-thread-condition_fulls_delete_callback.c | 18 ++++++++++------ .../test-thread-condition_fulls_destroy_callback.c | 18 ++++++++++------ .../test-thread-condition_fullss_delete_callback.c | 18 ++++++++++------ ...test-thread-condition_fullss_destroy_callback.c | 18 ++++++++++------ .../tests/unit/c/test-thread-lock_full_delete.c | 14 +++++++++---- .../c/test-thread-lock_fulls_delete_callback.c | 18 ++++++++++------ .../c/test-thread-lock_fulls_destroy_callback.c | 18 ++++++++++------ .../c/test-thread-lock_fullss_delete_callback.c | 18 ++++++++++------ .../c/test-thread-lock_fullss_destroy_callback.c | 18 ++++++++++------ .../tests/unit/c/test-thread-mutex_full_delete.c | 14 +++++++++---- .../c/test-thread-mutex_fulls_delete_callback.c | 18 ++++++++++------ .../c/test-thread-mutex_fulls_destroy_callback.c | 18 ++++++++++------ .../c/test-thread-mutex_fullss_delete_callback.c | 18 ++++++++++------ .../c/test-thread-mutex_fullss_destroy_callback.c | 18 ++++++++++------ 44 files changed, 424 insertions(+), 202 deletions(-) diff --git a/level_0/f_thread/c/thread/barrier_full.c b/level_0/f_thread/c/thread/barrier_full.c index f80ee68..c05215e 100644 --- a/level_0/f_thread/c/thread/barrier_full.c +++ b/level_0/f_thread/c/thread/barrier_full.c @@ -17,11 +17,11 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_barrier); } } - return pthread_barrierattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + return pthread_barrierattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay; } #endif // _di_f_thread_barrier_full_delete_ diff --git a/level_0/f_thread/c/thread/barrier_full.h b/level_0/f_thread/c/thread/barrier_full.h index 3520616..b7c6b8a 100644 --- a/level_0/f_thread/c/thread/barrier_full.h +++ b/level_0/f_thread/c/thread/barrier_full.h @@ -42,6 +42,8 @@ extern "C" { * The pthread_barrier_destroy() and pthread_barrierattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project. * Therefore there is only this function for both deleting and destroying. * + * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called. + * * @param full * The thread barrier_fulls to delete. * @@ -50,10 +52,11 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a barrier is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy(). * - * F_failure (with error bit) on any other error. + * F_attribute (with error bit) on error when calling pthread_barrierattr_destroy(). + * F_barrier (with error bit) on any error when calling pthread_barrier_destroy(). * * @see pthread_barrier_destroy() * @see pthread_barrierattr_destroy() diff --git a/level_0/f_thread/c/thread/barrier_fulls.c b/level_0/f_thread/c/thread/barrier_fulls.c index 9b0cd3b..f9248eb 100644 --- a/level_0/f_thread/c/thread/barrier_fulls.c +++ b/level_0/f_thread/c/thread/barrier_fulls.c @@ -18,10 +18,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_barrier); } - if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; @@ -42,10 +42,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_barrier); } - if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; diff --git a/level_0/f_thread/c/thread/barrier_fulls.h b/level_0/f_thread/c/thread/barrier_fulls.h index 9c4c888..a6cd869 100644 --- a/level_0/f_thread/c/thread/barrier_fulls.h +++ b/level_0/f_thread/c/thread/barrier_fulls.h @@ -45,6 +45,9 @@ extern "C" { * * This does not do parameter checking. * + * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +60,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a barrier is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_barrierattr_destroy(). + * F_barrier (with error bit) on any error when calling pthread_barrier_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_barrier_destroy() * @see pthread_barrierattr_destroy() @@ -79,6 +84,9 @@ extern "C" { * * This does not do parameter checking. * + * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +99,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a barrier is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_barrierattr_destroy(). + * F_barrier (with error bit) on any error when calling pthread_barrier_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_barrier_destroy() * @see pthread_barrierattr_destroy() diff --git a/level_0/f_thread/c/thread/barrier_fullss.c b/level_0/f_thread/c/thread/barrier_fullss.c index 158238d..eb2df0e 100644 --- a/level_0/f_thread/c/thread/barrier_fullss.c +++ b/level_0/f_thread/c/thread/barrier_fullss.c @@ -21,10 +21,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_barrier); } - if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { @@ -54,10 +54,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_barrier); } - if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { diff --git a/level_0/f_thread/c/thread/barrier_fullss.h b/level_0/f_thread/c/thread/barrier_fullss.h index 552d9d3..a6e50fa 100644 --- a/level_0/f_thread/c/thread/barrier_fullss.h +++ b/level_0/f_thread/c/thread/barrier_fullss.h @@ -45,6 +45,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called. + * When F_attribute or F_barrier (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +61,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a barrier is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_barrierattr_destroy(). + * F_barrier (with error bit) on any error when calling pthread_barrier_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_barrier_destroy() * @see pthread_barrierattr_destroy() @@ -79,6 +85,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called. + * When F_attribute or F_barrier (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +101,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a barrier is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_barrierattr_destroy(). + * F_barrier (with error bit) on any error when calling pthread_barrier_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_barrier_destroy() * @see pthread_barrierattr_destroy() diff --git a/level_0/f_thread/c/thread/condition_full.c b/level_0/f_thread/c/thread/condition_full.c index 5443393..801a66e 100644 --- a/level_0/f_thread/c/thread/condition_full.c +++ b/level_0/f_thread/c/thread/condition_full.c @@ -17,11 +17,11 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_condition); } } - return pthread_condattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + return pthread_condattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay; } #endif // _di_f_thread_condition_full_delete_ diff --git a/level_0/f_thread/c/thread/condition_full.h b/level_0/f_thread/c/thread/condition_full.h index 1b305da..8316720 100644 --- a/level_0/f_thread/c/thread/condition_full.h +++ b/level_0/f_thread/c/thread/condition_full.h @@ -40,6 +40,8 @@ extern "C" { * The pthread_condattr_destroy() and pthread_condattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project. * Therefore there is only this function for both deleting and destroying. * + * When F_barrier (with error bit) is returned, then pthread_condattr_destroy() is not called. + * * @param full * The full to delete. * @@ -48,10 +50,11 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if the full is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy(). * - * F_failure (with error bit) on any other error. + * F_attribute (with error bit) on error when calling pthread_condattr_destroy(). + * F_condition (with error bit) on any error when calling pthread_cond_destroy(). * * @see pthread_cond_destroy() * @see pthread_condattr_destroy() diff --git a/level_0/f_thread/c/thread/condition_fulls.c b/level_0/f_thread/c/thread/condition_fulls.c index e41b9b4..fbacb47 100644 --- a/level_0/f_thread/c/thread/condition_fulls.c +++ b/level_0/f_thread/c/thread/condition_fulls.c @@ -18,10 +18,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_condition); } - if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; @@ -42,10 +42,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_condition); } - if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; diff --git a/level_0/f_thread/c/thread/condition_fulls.h b/level_0/f_thread/c/thread/condition_fulls.h index 3616831..e413eb3 100644 --- a/level_0/f_thread/c/thread/condition_fulls.h +++ b/level_0/f_thread/c/thread/condition_fulls.h @@ -45,6 +45,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called. + * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +61,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a condition is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_condattr_destroy(). + * F_condition (with error bit) on any error when calling pthread_cond_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_cond_destroy() * @see pthread_condattr_destroy() @@ -79,6 +85,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called. + * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +101,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a condition is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_condattr_destroy(). + * F_condition (with error bit) on any error when calling pthread_cond_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_cond_destroy() * @see pthread_condattr_destroy() diff --git a/level_0/f_thread/c/thread/condition_fullss.c b/level_0/f_thread/c/thread/condition_fullss.c index 584eec6..5132807 100644 --- a/level_0/f_thread/c/thread/condition_fullss.c +++ b/level_0/f_thread/c/thread/condition_fullss.c @@ -21,10 +21,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_condition); } - if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { @@ -54,10 +54,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_condition); } - if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { diff --git a/level_0/f_thread/c/thread/condition_fullss.h b/level_0/f_thread/c/thread/condition_fullss.h index a8aea44..dcc3f28 100644 --- a/level_0/f_thread/c/thread/condition_fullss.h +++ b/level_0/f_thread/c/thread/condition_fullss.h @@ -45,6 +45,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called. + * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +61,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a condition is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_condattr_destroy(). + * F_condition (with error bit) on any error when calling pthread_cond_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_cond_destroy() * @see pthread_condattr_destroy() @@ -79,6 +85,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called. + * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +101,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a condition is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_condattr_destroy(). + * F_condition (with error bit) on any error when calling pthread_cond_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_cond_destroy() * @see pthread_condattr_destroy() diff --git a/level_0/f_thread/c/thread/lock_full.c b/level_0/f_thread/c/thread/lock_full.c index f8ba15e..6ff8fd6 100644 --- a/level_0/f_thread/c/thread/lock_full.c +++ b/level_0/f_thread/c/thread/lock_full.c @@ -17,11 +17,11 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_read_write); } } - return pthread_rwlockattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + return pthread_rwlockattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay; } #endif // _di_f_thread_lock_full_delete_ diff --git a/level_0/f_thread/c/thread/lock_full.h b/level_0/f_thread/c/thread/lock_full.h index e960c2a..77fcb77 100644 --- a/level_0/f_thread/c/thread/lock_full.h +++ b/level_0/f_thread/c/thread/lock_full.h @@ -40,6 +40,8 @@ extern "C" { * The pthread_rwlock_destroy() and pthread_rwlockattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project. * Therefore there is only this function for both deleting and destroying. * + * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called. + * * @param full * The full to delete. * @@ -50,8 +52,13 @@ extern "C" { * * F_parameter (with error bit) if a parameter is invalid. * - * F_failure (with error bit) on any other error. + * F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy(). + * F_read_write (with error bit) on any error when calling pthread_rwlock_destroy(). * + * @see pthread_rwlock_destroy() * @see pthread_rwlockattr_destroy() */ #ifndef _di_f_thread_lock_full_delete_ diff --git a/level_0/f_thread/c/thread/lock_fulls.c b/level_0/f_thread/c/thread/lock_fulls.c index f69097c..92187d4 100644 --- a/level_0/f_thread/c/thread/lock_fulls.c +++ b/level_0/f_thread/c/thread/lock_fulls.c @@ -19,10 +19,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_read_write); } - if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; @@ -43,10 +43,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_read_write); } - if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; diff --git a/level_0/f_thread/c/thread/lock_fulls.h b/level_0/f_thread/c/thread/lock_fulls.h index 37a9544..8d4c813 100644 --- a/level_0/f_thread/c/thread/lock_fulls.h +++ b/level_0/f_thread/c/thread/lock_fulls.h @@ -45,6 +45,8 @@ extern "C" { * * This does not do parameter checking. * + * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +59,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a lock is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy(). + * F_read_write (with error bit) on any error when calling pthread_rwlock_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_rwlock_destroy() * @see pthread_rwlockattr_destroy() @@ -79,6 +83,8 @@ extern "C" { * * This does not do parameter checking. * + * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +97,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a lock is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy(). + * F_read_write (with error bit) on any error when calling pthread_rwlock_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_rwlock_destroy() * @see pthread_rwlockattr_destroy() diff --git a/level_0/f_thread/c/thread/lock_fullss.c b/level_0/f_thread/c/thread/lock_fullss.c index e080853..7bbe47c 100644 --- a/level_0/f_thread/c/thread/lock_fullss.c +++ b/level_0/f_thread/c/thread/lock_fullss.c @@ -21,10 +21,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_read_write); } - if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { @@ -54,10 +54,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_read_write); } - if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { diff --git a/level_0/f_thread/c/thread/lock_fullss.h b/level_0/f_thread/c/thread/lock_fullss.h index cb5a17c..295ecb4 100644 --- a/level_0/f_thread/c/thread/lock_fullss.h +++ b/level_0/f_thread/c/thread/lock_fullss.h @@ -45,6 +45,8 @@ extern "C" { * * This does not do parameter checking. * + * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +59,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a lock is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy(). + * F_read_write (with error bit) on any error when calling pthread_rwlock_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_rwlock_destroy() * @see pthread_rwlockattr_destroy() @@ -79,6 +83,8 @@ extern "C" { * * This does not do parameter checking. * + * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +97,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a lock is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy(). + * F_read_write (with error bit) on any error when calling pthread_rwlock_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_rwlock_destroy() * @see pthread_rwlockattr_destroy() diff --git a/level_0/f_thread/c/thread/mutex_full.c b/level_0/f_thread/c/thread/mutex_full.c index 431a575..e9b5dc3 100644 --- a/level_0/f_thread/c/thread/mutex_full.c +++ b/level_0/f_thread/c/thread/mutex_full.c @@ -17,11 +17,11 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_mutex); } } - return pthread_mutexattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + return pthread_mutexattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay; } #endif // _di_f_thread_mutex_full_delete_ diff --git a/level_0/f_thread/c/thread/mutex_full.h b/level_0/f_thread/c/thread/mutex_full.h index 350741f..1ce6d96 100644 --- a/level_0/f_thread/c/thread/mutex_full.h +++ b/level_0/f_thread/c/thread/mutex_full.h @@ -40,6 +40,8 @@ extern "C" { * The pthread_mutex_destroy() and pthread_mutexattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project. * Therefore there is only this function for both deleting and destroying. * + * When F_mutex (with error bit) is returned, then pthread_condattr_destroy() is not called. + * * @param full * The full to delete. * @@ -48,10 +50,11 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if the mutex is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy(). * - * F_failure (with error bit) on any other error. + * F_attribute (with error bit) on error when calling pthread_mutexattr_destroy(). + * F_mutex (with error bit) on any error when calling pthread_mutex_destroy(). * * @see pthread_mutex_destroy() * @see pthread_mutexattr_destroy() diff --git a/level_0/f_thread/c/thread/mutex_fulls.c b/level_0/f_thread/c/thread/mutex_fulls.c index 0e2e14d..286eafb 100644 --- a/level_0/f_thread/c/thread/mutex_fulls.c +++ b/level_0/f_thread/c/thread/mutex_fulls.c @@ -18,10 +18,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_mutex); } - if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; @@ -42,10 +42,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_mutex); } - if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute); } // for return F_okay; diff --git a/level_0/f_thread/c/thread/mutex_fulls.h b/level_0/f_thread/c/thread/mutex_fulls.h index 6989a80..ae879b2 100644 --- a/level_0/f_thread/c/thread/mutex_fulls.h +++ b/level_0/f_thread/c/thread/mutex_fulls.h @@ -45,6 +45,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called. + * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +61,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a mutex is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_mutexattr_destroy(). + * F_mutex (with error bit) on any error when calling pthread_mutex_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_mutex_destroy() * @see pthread_mutexattr_destroy() @@ -79,6 +85,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called. + * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +101,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a mutex is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_mutexattr_destroy(). + * F_mutex (with error bit) on any error when calling pthread_mutex_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_mutex_destroy() * @see pthread_mutexattr_destroy() diff --git a/level_0/f_thread/c/thread/mutex_fullss.c b/level_0/f_thread/c/thread/mutex_fullss.c index 0d766be..e89740e 100644 --- a/level_0/f_thread/c/thread/mutex_fullss.c +++ b/level_0/f_thread/c/thread/mutex_fullss.c @@ -21,10 +21,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_mutex); } - if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { @@ -54,10 +54,10 @@ extern "C" { if (error == EBUSY) return F_status_set_error(F_busy); if (error == EINVAL) return F_status_set_error(F_parameter); - return F_status_set_error(F_failure); + return F_status_set_error(F_mutex); } - if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute); } // for if (array[i].size && array[i].array) { diff --git a/level_0/f_thread/c/thread/mutex_fullss.h b/level_0/f_thread/c/thread/mutex_fullss.h index 1abf863..7ac9b42 100644 --- a/level_0/f_thread/c/thread/mutex_fullss.h +++ b/level_0/f_thread/c/thread/mutex_fullss.h @@ -45,6 +45,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called. + * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -57,13 +61,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a mutex is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_mutexattr_destroy(). + * F_mutex (with error bit) on any error when calling pthread_mutex_destroy(). * * Errors (with error bit) from: f_memory_array_resize(). * * @see f_memory_array_resize() - * @see f_memory_arrays_resize() * * @see pthread_mutex_destroy() * @see pthread_mutexattr_destroy() @@ -79,6 +85,10 @@ extern "C" { * * This does not do parameter checking. * + * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called. + * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called. + * On any error, the array is not guaranteed to be completely processed. + * * @param start * The inclusive start position in the array to start deleting. * @param stop @@ -91,13 +101,15 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if a mutex is busy. - * F_parameter (with error bit) if a parameter is invalid. + * F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy(). + * F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy(). + * + * F_attribute (with error bit) on error when calling pthread_mutexattr_destroy(). + * F_mutex (with error bit) on any error when calling pthread_mutex_destroy(). * * Errors (with error bit) from: f_memory_array_adjust(). * * @see f_memory_array_adjust() - * @see f_memory_arrays_adjust() * * @see pthread_mutex_destroy() * @see pthread_mutexattr_destroy() diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c index f2d73f5..ac75c34 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c @@ -15,10 +15,16 @@ void test__f_thread_barrier_full_delete__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_barrier, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -28,7 +34,7 @@ void test__f_thread_barrier_full_delete__fails(void **state) { const f_status_t status = f_thread_barrier_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -40,7 +46,7 @@ void test__f_thread_barrier_full_delete__fails(void **state) { const f_status_t status = f_thread_barrier_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c index 61a972f..7111371 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c @@ -18,10 +18,16 @@ void test__f_thread_barrier_fulls_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_barrier, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_barrier_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_barrier_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c index 02ce59d..8c88b67 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c @@ -18,10 +18,16 @@ void test__f_thread_barrier_fulls_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_barrier, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_barrier_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_barrier_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c index a1098a9..b346bbf 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c @@ -20,10 +20,16 @@ void test__f_thread_barrier_fullss_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_barrier, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_barrier_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_barrier_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c index 67c3469..b0b24ca 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c @@ -20,10 +20,16 @@ void test__f_thread_barrier_fullss_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_barrier, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_barrier_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_barrier_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_barrier_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c index 7e40b37..d102f78 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c @@ -15,10 +15,16 @@ void test__f_thread_condition_full_delete__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_condition, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -28,7 +34,7 @@ void test__f_thread_condition_full_delete__fails(void **state) { const f_status_t status = f_thread_condition_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -40,7 +46,7 @@ void test__f_thread_condition_full_delete__fails(void **state) { const f_status_t status = f_thread_condition_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c index 7597a45..0c02b9e 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c @@ -18,10 +18,16 @@ void test__f_thread_condition_fulls_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_condition, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_condition_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_condition_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_condition_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_condition_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c index bf7d092..54d7c35 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c @@ -18,10 +18,16 @@ void test__f_thread_condition_fulls_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_condition, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_condition_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_condition_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_condition_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_condition_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c index 3cf49ef..731a231 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c @@ -20,10 +20,16 @@ void test__f_thread_condition_fullss_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_condition, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_condition_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_condition_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_condition_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_condition_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c index 9177559..cce03ef 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c @@ -20,10 +20,16 @@ void test__f_thread_condition_fullss_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_condition, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_condition_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_condition_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_condition_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_condition_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c index 6fd6a76..18117f7 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c @@ -15,10 +15,16 @@ void test__f_thread_lock_full_delete__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_read_write, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -28,7 +34,7 @@ void test__f_thread_lock_full_delete__fails(void **state) { const f_status_t status = f_thread_lock_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -40,7 +46,7 @@ void test__f_thread_lock_full_delete__fails(void **state) { const f_status_t status = f_thread_lock_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } // for } diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c index 884b601..71f934c 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c @@ -18,10 +18,16 @@ void test__f_thread_lock_fulls_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_read_write, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_lock_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_lock_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_lock_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_lock_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c index 4ce2837..d35bc53 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c @@ -18,10 +18,16 @@ void test__f_thread_lock_fulls_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_read_write, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_lock_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_lock_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_lock_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_lock_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c index 64f57b6..d7670e1 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c @@ -20,10 +20,16 @@ void test__f_thread_lock_fullss_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_read_write, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_lock_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_lock_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_lock_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_lock_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c index 32cf077..47030d8 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c @@ -20,10 +20,16 @@ void test__f_thread_lock_fullss_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_read_write, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_lock_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_lock_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_lock_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_lock_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c index 411c9b1..7fa3802 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c @@ -15,10 +15,16 @@ void test__f_thread_mutex_full_delete__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { + f_status_t statuss_1[] = { F_busy, F_parameter, - F_failure, + F_mutex, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -28,7 +34,7 @@ void test__f_thread_mutex_full_delete__fails(void **state) { const f_status_t status = f_thread_mutex_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -40,7 +46,7 @@ void test__f_thread_mutex_full_delete__fails(void **state) { const f_status_t status = f_thread_mutex_full_delete(&full); - assert_int_equal(status, F_status_set_error(statuss[i])); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c index b657c66..15db480 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c @@ -18,10 +18,16 @@ void test__f_thread_mutex_fulls_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_mutex, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_mutex_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_mutex_fulls_delete_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fulls_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c index 68e677f..bdbc82d 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c @@ -18,10 +18,16 @@ void test__f_thread_mutex_fulls_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_mutex, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -31,7 +37,7 @@ void test__f_thread_mutex_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -43,7 +49,7 @@ void test__f_thread_mutex_fulls_destroy_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fulls_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c index d52b04c..10ca0e5 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c @@ -20,10 +20,16 @@ void test__f_thread_mutex_fullss_delete_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_mutex, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_mutex_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_mutex_fullss_delete_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fullss_delete_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c index 3c4f1b7..17b9250 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c @@ -20,10 +20,16 @@ void test__f_thread_mutex_fullss_destroy_callback__fails(void **state) { mock_errno_generic, }; - f_status_t statuss[] = { - F_status_set_error(F_busy), - F_status_set_error(F_parameter), - F_status_set_error(F_failure), + f_status_t statuss_1[] = { + F_busy, + F_parameter, + F_mutex, + }; + + f_status_t statuss_2[] = { + F_busy, + F_parameter, + F_attribute, }; for (uint8_t i = 0; i < 3; ++i) { @@ -33,7 +39,7 @@ void test__f_thread_mutex_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_1[i])); } // for { @@ -45,7 +51,7 @@ void test__f_thread_mutex_fullss_destroy_callback__fails(void **state) { const f_status_t status = f_thread_mutex_fullss_destroy_callback(0, 1, (void *) datass_array); - assert_int_equal(status, statuss[i]); + assert_int_equal(status, F_status_set_error(statuss_2[i])); } } -- 1.8.3.1