From 45d3341ae39b9f46f757e12a835f2fa410427683 Mon Sep 17 00:00:00 2001 From: Kevin Day Date: Sat, 16 Aug 2025 00:18:09 -0500 Subject: [PATCH] Update: Provide "full" thread types and corrects other problems encountered. There are new types like `f_thread_barrier_full_t` created that provide a structure of both the lock and its associated attribute variable. For whatever reason the pthread design requires the attributes to be allocated. This makes changing settings more complex. These "full" types are provided to help reduce the burden of managing this mess. I noticed a lot of random inconsistencies and other minor mistakes that I decided to simply address while working on this. There are more things that could be done but I decided to limit myself to what is done here. Of particular note are the attribute functions. Several of the attribute functions were checking for error codes that do not exist as per the standard. The attribute functions simply return fewer possible error codes that the locks. I more than likely mass copied the locks into attributes and never corrects the dependencies. Several of the tests were also testing these invalid status codes. --- level_0/f_thread/c/thread.c | 127 +++++++++---- level_0/f_thread/c/thread.h | 123 ++++++++++++- level_0/f_thread/c/thread/barrier_full.c | 124 +++++++++++++ level_0/f_thread/c/thread/barrier_full.h | 199 +++++++++++++++++++++ level_0/f_thread/c/thread/condition.h | 8 +- level_0/f_thread/c/thread/condition_attribute.c | 104 ++++------- level_0/f_thread/c/thread/condition_attribute.h | 2 +- level_0/f_thread/c/thread/condition_full.c | 124 +++++++++++++ level_0/f_thread/c/thread/condition_full.h | 199 +++++++++++++++++++++ level_0/f_thread/c/thread/lock_attribute.c | 104 ++++------- level_0/f_thread/c/thread/lock_full.c | 124 +++++++++++++ level_0/f_thread/c/thread/lock_full.h | 199 +++++++++++++++++++++ level_0/f_thread/c/thread/mutex_attribute.c | 104 ++++------- level_0/f_thread/c/thread/mutex_full.c | 124 +++++++++++++ level_0/f_thread/c/thread/mutex_full.h | 199 +++++++++++++++++++++ level_0/f_thread/data/build/settings | 4 +- level_0/f_thread/data/build/settings-mocks | 4 +- level_0/f_thread/data/build/settings-tests | 45 +++-- .../tests/unit/c/test-thread-barrier_full_delete.c | 72 ++++++++ .../tests/unit/c/test-thread-barrier_full_delete.h | 34 ++++ .../c/test-thread-barrier_fulls_delete_callback.c | 70 ++++++++ .../c/test-thread-barrier_fulls_delete_callback.h | 27 +++ .../c/test-thread-barrier_fulls_destroy_callback.c | 70 ++++++++ .../c/test-thread-barrier_fulls_destroy_callback.h | 27 +++ .../unit/c/test-thread-barriers_delete_callback.c | 1 + .../c/test-thread-condition_attribute_delete.c | 6 +- ...t-thread-condition_attributes_delete_callback.c | 6 +- ...-thread-condition_attributes_destroy_callback.c | 6 +- .../unit/c/test-thread-condition_full_delete.c | 72 ++++++++ .../unit/c/test-thread-condition_full_delete.h | 34 ++++ .../test-thread-condition_fulls_delete_callback.c | 70 ++++++++ .../test-thread-condition_fulls_delete_callback.h | 27 +++ .../test-thread-condition_fulls_destroy_callback.c | 70 ++++++++ .../test-thread-condition_fulls_destroy_callback.h | 27 +++ .../unit/c/test-thread-lock_attribute_delete.c | 6 +- .../unit/c/test-thread-lock_attribute_delete.h | 7 + .../test-thread-lock_attributes_delete_callback.c | 6 +- .../test-thread-lock_attributes_destroy_callback.c | 6 +- .../tests/unit/c/test-thread-lock_full_delete.c | 72 ++++++++ .../tests/unit/c/test-thread-lock_full_delete.h | 34 ++++ .../c/test-thread-lock_fulls_delete_callback.c | 70 ++++++++ .../c/test-thread-lock_fulls_delete_callback.h | 27 +++ .../c/test-thread-lock_fulls_destroy_callback.c | 70 ++++++++ .../c/test-thread-lock_fulls_destroy_callback.h | 27 +++ .../unit/c/test-thread-mutex_attribute_delete.c | 6 +- .../test-thread-mutex_attributes_delete_callback.c | 6 +- ...test-thread-mutex_attributes_destroy_callback.c | 6 +- .../tests/unit/c/test-thread-mutex_full_delete.c | 72 ++++++++ .../tests/unit/c/test-thread-mutex_full_delete.h | 34 ++++ .../c/test-thread-mutex_fulls_delete_callback.c | 70 ++++++++ .../c/test-thread-mutex_fulls_delete_callback.h | 27 +++ .../c/test-thread-mutex_fulls_destroy_callback.c | 70 ++++++++ .../c/test-thread-mutex_fulls_destroy_callback.h | 27 +++ level_0/f_thread/tests/unit/c/test-thread.c | 131 ++++++++++---- level_0/f_thread/tests/unit/c/test-thread.h | 65 ++++--- 55 files changed, 2971 insertions(+), 404 deletions(-) create mode 100644 level_0/f_thread/c/thread/barrier_full.c create mode 100644 level_0/f_thread/c/thread/barrier_full.h create mode 100644 level_0/f_thread/c/thread/condition_full.c create mode 100644 level_0/f_thread/c/thread/condition_full.h create mode 100644 level_0/f_thread/c/thread/lock_full.c create mode 100644 level_0/f_thread/c/thread/lock_full.h create mode 100644 level_0/f_thread/c/thread/mutex_full.c create mode 100644 level_0/f_thread/c/thread/mutex_full.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.h create mode 100644 level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c create mode 100644 level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.h diff --git a/level_0/f_thread/c/thread.c b/level_0/f_thread/c/thread.c index 8ed74b2..a481f35 100644 --- a/level_0/f_thread/c/thread.c +++ b/level_0/f_thread/c/thread.c @@ -570,6 +570,27 @@ extern "C" { } #endif // _di_f_thread_barrier_delete_ +#ifndef _di_f_thread_barrier_full_delete_ + f_status_t f_thread_barrier_full_delete(f_thread_barrier_full_t * const full) { + #ifndef _di_level_0_parameter_checking_ + if (!full) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + { + const int error = pthread_barrier_destroy(&full->barrier); + + if (error) { + 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 pthread_barrierattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + } +#endif // _di_f_thread_barrier_full_delete_ + #ifndef _di_f_thread_barrier_wait_ f_status_t f_thread_barrier_wait(f_thread_barrier_t * const barrier, int * const result) { #ifndef _di_level_0_parameter_checking_ @@ -745,23 +766,12 @@ extern "C" { #endif // _di_f_thread_condition_attribute_create_ #ifndef _di_f_thread_condition_attribute_delete_ - f_status_t f_thread_condition_attribute_delete(f_thread_condition_attribute_t * const condition_attribute) { + f_status_t f_thread_condition_attribute_delete(f_thread_condition_attribute_t * const attribute) { #ifndef _di_level_0_parameter_checking_ - if (!condition_attribute) return F_status_set_error(F_parameter); + if (!attribute) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ - { - const int error = pthread_condattr_destroy(condition_attribute); - - if (error) { - 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_okay; + return pthread_condattr_destroy(attribute) ? F_status_set_error(F_failure) : F_okay; } #endif // _di_f_thread_condition_attribute_delete_ @@ -842,6 +852,27 @@ extern "C" { } #endif // _di_f_thread_condition_delete_ +#ifndef _di_f_thread_condition_full_delete_ + f_status_t f_thread_condition_full_delete(f_thread_condition_full_t * const full) { + #ifndef _di_level_0_parameter_checking_ + if (!full) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + { + const int error = pthread_cond_destroy(&full->condition); + + if (error) { + 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 pthread_condattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + } +#endif // _di_f_thread_condition_full_delete_ + #ifndef _di_f_thread_condition_signal_ f_status_t f_thread_condition_signal(f_thread_condition_t * const condition) { #ifndef _di_level_0_parameter_checking_ @@ -1121,16 +1152,7 @@ extern "C" { if (!attribute) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ - const int error = pthread_rwlockattr_destroy(attribute); - - if (error) { - 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_okay; + return pthread_rwlockattr_destroy(attribute) ? F_status_set_error(F_failure) : F_okay; } #endif // _di_f_thread_lock_attribute_delete_ @@ -1193,7 +1215,7 @@ extern "C" { #endif // _di_level_0_parameter_checking_ { - int error = pthread_rwlock_destroy(lock); + const int error = pthread_rwlock_destroy(lock); if (error) { if (error == EBUSY) return F_status_set_error(F_busy); @@ -1207,6 +1229,27 @@ extern "C" { } #endif // _di_f_thread_lock_delete_ +#ifndef _di_f_thread_lock_full_delete_ + f_status_t f_thread_lock_full_delete(f_thread_lock_full_t * const full) { + #ifndef _di_level_0_parameter_checking_ + if (!full) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + { + const int error = pthread_rwlock_destroy(&full->lock); + + if (error) { + 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 pthread_rwlockattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + } +#endif // _di_f_thread_lock_full_delete_ + #ifndef _di_f_thread_lock_read_ f_status_t f_thread_lock_read(f_thread_lock_t * const lock) { #ifndef _di_level_0_parameter_checking_ @@ -1358,18 +1401,7 @@ extern "C" { if (!attribute) return F_status_set_error(F_parameter); #endif // _di_level_0_parameter_checking_ - { - const int error = pthread_mutexattr_destroy(attribute); - - if (error) { - 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_okay; + return pthread_mutexattr_destroy(attribute) ? F_status_set_error(F_failure) : F_okay; } #endif // _di_f_thread_mutex_attribute_delete_ @@ -1631,6 +1663,27 @@ extern "C" { } #endif // _di_f_thread_mutex_delete_ +#ifndef _di_f_thread_mutex_full_delete_ + f_status_t f_thread_mutex_full_delete(f_thread_mutex_full_t * const full) { + #ifndef _di_level_0_parameter_checking_ + if (!full) return F_status_set_error(F_parameter); + #endif // _di_level_0_parameter_checking_ + + { + const int error = pthread_mutex_destroy(&full->mutex); + + if (error) { + 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 pthread_mutexattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay; + } +#endif // _di_f_thread_mutex_full_delete_ + #ifndef _di_f_thread_mutex_lock_ f_status_t f_thread_mutex_lock(f_thread_mutex_t * const mutex) { #ifndef _di_level_0_parameter_checking_ diff --git a/level_0/f_thread/c/thread.h b/level_0/f_thread/c/thread.h index 58850b0..f352683 100644 --- a/level_0/f_thread/c/thread.h +++ b/level_0/f_thread/c/thread.h @@ -34,14 +34,18 @@ #include #include #include +#include #include #include +#include #include #include #include #include +#include #include #include +#include #include #include #include @@ -789,6 +793,7 @@ 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_failure (with error bit) on any other error. @@ -800,6 +805,34 @@ extern "C" { #endif // _di_f_thread_barrier_delete_ /** + * Delete a thread barrier full structure. + * + * On successfully delete, the pointer address is set to 0. + * + * 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. + * + * @param full + * The thread barrier_fulls to delete. + * + * Must not be NULL. + * + * @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_failure (with error bit) on any other error. + * + * @see pthread_barrier_destroy() + * @see pthread_barrierattr_destroy() + */ +#ifndef _di_f_thread_barrier_full_delete_ + extern f_status_t f_thread_barrier_full_delete(f_thread_barrier_full_t * const full); +#endif // _di_f_thread_barrier_full_delete_ + +/** * Wait on a barrier, effectively synchronizing multiple threads with some barrier. * * @param barrier @@ -1026,7 +1059,7 @@ extern "C" { #endif // _di_f_thread_condition_attribute_clock_set_ /** - * Delete a thread attribute. + * Delete a thread condition attribute. * * The pthread_condattr_destroy() function has no distinction like the *_destroy() and the *_delete() used by the FLL project. * Therefore there is only this function for both deleting and destroying. @@ -1039,7 +1072,6 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if the attribute is busy. * F_parameter (with error bit) if a parameter is invalid. * * F_failure (with error bit) on any other error. @@ -1130,6 +1162,7 @@ extern "C" { * * F_busy (with error bit) if the condition is busy. * F_parameter (with error bit) if a parameter is invalid. + * * F_failure (with error bit) on any other error. * * @see pthread_cond_destroy() @@ -1139,6 +1172,32 @@ extern "C" { #endif // _di_f_thread_condition_delete_ /** + * Delete a thread condition full. + * + * 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. + * + * @param full + * The full to delete. + * + * Must not be NULL. + * + * @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_failure (with error bit) on any other error. + * + * @see pthread_cond_destroy() + * @see pthread_condattr_destroy() + */ +#ifndef _di_f_thread_condition_full_delete_ + extern f_status_t f_thread_condition_full_delete(f_thread_condition_full_t * const full); +#endif // _di_f_thread_condition_full_delete_ + +/** * Signal a thread waiting on a condition. * * Only a single thread waiting on this condition is signaled. @@ -1541,7 +1600,7 @@ extern "C" { /** * Delete a thread lock attribute. * - * The pthread_lockattr_destroy() function has no distinction like the *_destroy() and the *_delete() used by the FLL project. + * The pthread_rwlockattr_destroy() function has no distinction like the *_destroy() and the *_delete() used by the FLL project. * Therefore there is only this function for both deleting and destroying. * * @param attribute @@ -1552,7 +1611,6 @@ extern "C" { * @return * F_okay on success. * - * F_busy (with error bit) if the lock is busy. * F_parameter (with error bit) if a parameter is invalid. * * F_failure (with error bit) on any other error. @@ -1639,7 +1697,7 @@ extern "C" { /** * Delete a thread read/write lock. * - * The pthread_lock_destroy() function has no distinction like the *_destroy() and the *_delete() used by the FLL project. + * The pthread_rwlock_destroy() function has no distinction like the *_destroy() and the *_delete() used by the FLL project. * Therefore there is only this function for both deleting and destroying. * * @param lock @@ -1662,6 +1720,30 @@ extern "C" { #endif // _di_f_thread_lock_delete_ /** + * Delete a thread lock full. + * + * 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. + * + * @param full + * The full to delete. + * + * Must not be NULL. + * + * @return + * F_okay on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * F_failure (with error bit) on any other error. + * + * @see pthread_rwlockattr_destroy() + */ +#ifndef _di_f_thread_lock_full_delete_ + extern f_status_t f_thread_lock_full_delete(f_thread_lock_full_t * const full); +#endif // _di_f_thread_lock_full_delete_ + +/** * Lock the read part of a read/write lock. * * This is a blocking function. @@ -1844,6 +1926,7 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. * F_prohibited (with error bit) if not allowed to perform the operation. * F_resource_not (with error bit) if max mutexes is reached. + * * F_failure (with error bit) on any other error. * * @see pthread_mutexattr_init() @@ -1866,8 +1949,8 @@ 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_failure (with error bit) on any other error. * * @see pthread_mutexattr_destroy() @@ -1990,6 +2073,7 @@ extern "C" { * F_okay on success. * * F_parameter (with error bit) if a parameter is invalid. + * * F_failure (with error bit) on any other error. * * @see pthread_mutexattr_setrobust() @@ -2013,6 +2097,7 @@ extern "C" { * F_okay on success. * * F_parameter (with error bit) if a parameter is invalid. + * * F_failure (with error bit) on any other error. * * @see pthread_mutexattr_setrobust() @@ -2197,6 +2282,32 @@ extern "C" { #endif // _di_f_thread_mutex_delete_ /** + * Delete a thread mutex full. + * + * 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. + * + * @param full + * The full to delete. + * + * Must not be NULL. + * + * @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_failure (with error bit) on any other error. + * + * @see pthread_mutex_destroy() + * @see pthread_mutexattr_destroy() + */ +#ifndef _di_f_thread_mutex_full_delete_ + extern f_status_t f_thread_mutex_full_delete(f_thread_mutex_full_t * const full); +#endif // _di_f_thread_mutex_full_delete_ + +/** * Get the mutex priority ceiling. * * @param mutex diff --git a/level_0/f_thread/c/thread/barrier_full.c b/level_0/f_thread/c/thread/barrier_full.c new file mode 100644 index 0000000..f661306 --- /dev/null +++ b/level_0/f_thread/c/thread/barrier_full.c @@ -0,0 +1,124 @@ +#include "../thread.h" +#include "barrier_full.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _di_f_thread_barrier_fulls_delete_callback_ + f_status_t f_thread_barrier_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_barrier_full_t * const array = (f_thread_barrier_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_barrier_destroy(&array[i].barrier); + + if (error) { + 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); + } + + if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_barrier_fulls_delete_callback_ + +#ifndef _di_f_thread_barrier_fulls_destroy_callback_ + f_status_t f_thread_barrier_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_barrier_full_t * const array = (f_thread_barrier_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_barrier_destroy(&array[i].barrier); + + if (error) { + 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); + } + + if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_barrier_fulls_destroy_callback_ + +#ifndef _di_f_thread_barrier_fullss_delete_callback_ + f_status_t f_thread_barrier_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_barrier_fulls_t * const array = (f_thread_barrier_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_barrier_destroy(&array[i].array[j].barrier); + + if (error) { + 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); + } + + if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_barrier_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_barrier_fullss_delete_callback_ + +#ifndef _di_f_thread_barrier_fullss_destroy_callback_ + f_status_t f_thread_barrier_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_barrier_fulls_t * const array = (f_thread_barrier_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_barrier_destroy(&array[i].array[j].barrier); + + if (error) { + 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); + } + + if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_barrier_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_barrier_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/c/thread/barrier_full.h b/level_0/f_thread/c/thread/barrier_full.h new file mode 100644 index 0000000..e7e0aa5 --- /dev/null +++ b/level_0/f_thread/c/thread/barrier_full.h @@ -0,0 +1,199 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Defines common data to be used for/by POSIX thread related functionality. + * + * This is auto-included by thread.h and should not need to be explicitly included. + */ +#ifndef _F_thread_barrier_full_h +#define _F_thread_barrier_full_h + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * A structure of the barrier and its associated attribute. + * + * Properties: + * - barrier: The barrier. + * - attribute: The associated attribute. + */ +#ifndef _di_f_thread_barrier_full_t_ + typedef struct { + f_thread_barrier_t barrier; + f_thread_barrier_attribute_t attribute; + } f_thread_barrier_full_t; + + #define f_thread_barrier_full_t_initialize { f_thread_barrier_t_initialize, f_thread_barrier_attribute_t_initialize } + + #define macro_f_thread_barrier_full_t_initialize_1(barrier, attribute) { barrier, attribute } +#endif // _di_f_thread_barrier_full_t_ + +/** + * An array of f_thread_barrier_full_t. + * + * Properties: + * - array: The array of f_thread_barrier_full_t. + * - size: Total amount of allocated space. + * - used: Total number of allocated spaces used. + */ +#ifndef _di_f_thread_barrier_fulls_t_ + typedef struct { + f_thread_barrier_full_t *array; + + f_number_unsigned_t size; + f_number_unsigned_t used; + } f_thread_barrier_fulls_t; + + #define f_thread_barrier_fulls_t_initialize { 0, 0, 0 } + + #define macro_f_thread_barrier_fulls_t_initialize_1(array, size, used) { array, size, used } + #define macro_f_thread_barrier_fulls_t_initialize_2(array, length) { array, length, length } +#endif // _di_f_thread_barrier_fulls_t_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_barrier_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_barrier_fulls_delete_callback_ + extern f_status_t f_thread_barrier_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_barrier_fulls_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_barrier_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_barrier_fulls_destroy_callback_ + extern f_status_t f_thread_barrier_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_barrier_fulls_destroy_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_barrier_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_barrier_fullss_delete_callback_ + extern f_status_t f_thread_barrier_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_barrier_fullss_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_barrier_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_barrier_fullss_destroy_callback_ + extern f_status_t f_thread_barrier_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_barrier_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _F_thread_barrier_full_h diff --git a/level_0/f_thread/c/thread/condition.h b/level_0/f_thread/c/thread/condition.h index 4f6dcdd..53dd189 100644 --- a/level_0/f_thread/c/thread/condition.h +++ b/level_0/f_thread/c/thread/condition.h @@ -79,7 +79,7 @@ extern "C" { * @see f_memory_array_resize() * @see f_memory_arrays_resize() * - * @see pthread_condition_destroy() + * @see pthread_cond_destroy() */ #ifndef _di_f_thread_conditions_delete_callback_ extern f_status_t f_thread_conditions_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); @@ -112,7 +112,7 @@ extern "C" { * @see f_memory_array_adjust() * @see f_memory_arrays_adjust() * - * @see pthread_condition_destroy() + * @see pthread_cond_destroy() */ #ifndef _di_f_thread_conditions_destroy_callback_ extern f_status_t f_thread_conditions_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); @@ -145,7 +145,7 @@ extern "C" { * @see f_memory_array_resize() * @see f_memory_arrays_resize() * - * @see pthread_condition_destroy() + * @see pthread_cond_destroy() */ #ifndef _di_f_thread_conditionss_delete_callback_ extern f_status_t f_thread_conditionss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); @@ -178,7 +178,7 @@ extern "C" { * @see f_memory_array_adjust() * @see f_memory_arrays_adjust() * - * @see pthread_condition_destroy() + * @see pthread_cond_destroy() */ #ifndef _di_f_thread_conditionss_destroy_callback_ extern f_status_t f_thread_conditionss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); diff --git a/level_0/f_thread/c/thread/condition_attribute.c b/level_0/f_thread/c/thread/condition_attribute.c index 6b98d52..a7b36f1 100644 --- a/level_0/f_thread/c/thread/condition_attribute.c +++ b/level_0/f_thread/c/thread/condition_attribute.c @@ -8,22 +8,11 @@ extern "C" { #ifndef _di_f_thread_condition_attributes_delete_callback_ f_status_t f_thread_condition_attributes_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_condition_attribute_t * const array = (f_thread_condition_attribute_t *) void_array; - int error = 0; + f_thread_condition_attribute_t * const array = (f_thread_condition_attribute_t *) void_array; - for (f_number_unsigned_t i = start; i < stop; ++i) { - - error = pthread_condattr_destroy(&array[i]); - - if (error) { - 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); - } - } // for - } + for (f_number_unsigned_t i = start; i < stop; ++i) { + if (pthread_condattr_destroy(&array[i])) return F_status_set_error(F_failure); + } // for return F_okay; } @@ -32,22 +21,11 @@ extern "C" { #ifndef _di_f_thread_condition_attributes_destroy_callback_ f_status_t f_thread_condition_attributes_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_condition_attribute_t * const array = (f_thread_condition_attribute_t *) void_array; - int error = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_condition_attribute_t * const array = (f_thread_condition_attribute_t *) void_array; - error = pthread_condattr_destroy(&array[i]); - - if (error) { - 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); - } - } // for - } + for (f_number_unsigned_t i = start; i < stop; ++i) { + if (pthread_condattr_destroy(&array[i])) return F_status_set_error(F_failure); + } // for return F_okay; } @@ -56,31 +34,20 @@ extern "C" { #ifndef _di_f_thread_condition_attributess_delete_callback_ f_status_t f_thread_condition_attributess_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_condition_attributes_t * const array = (f_thread_condition_attributes_t *) void_array; - int error = 0; - f_number_unsigned_t j = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_condition_attributes_t * const array = (f_thread_condition_attributes_t *) void_array; + f_number_unsigned_t j = 0; - for (j = 0; j < array[i].size; ++j) { + for (f_number_unsigned_t i = start; i < stop; ++i) { - error = pthread_condattr_destroy(&array[i].array[j]); - - if (error) { - 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); - } - } // for - - if (array[i].size && array[i].array) { - const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_condition_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); - if (F_status_is_error(status)) return status; - } + for (j = 0; j < array[i].size; ++j) { + if (pthread_condattr_destroy(&array[i].array[j])) return F_status_set_error(F_failure); } // for - } + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_condition_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for return F_okay; } @@ -89,31 +56,20 @@ extern "C" { #ifndef _di_f_thread_condition_attributess_destroy_callback_ f_status_t f_thread_condition_attributess_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_condition_attributes_t * const array = (f_thread_condition_attributes_t *) void_array; - int error = 0; - f_number_unsigned_t j = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_condition_attributes_t * const array = (f_thread_condition_attributes_t *) void_array; + f_number_unsigned_t j = 0; - for (j = 0; j < array[i].size; ++j) { + for (f_number_unsigned_t i = start; i < stop; ++i) { - error = pthread_condattr_destroy(&array[i].array[j]); - - if (error) { - 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); - } - } // for - - if (array[i].size && array[i].array) { - const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_condition_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); - if (F_status_is_error(status)) return status; - } + for (j = 0; j < array[i].size; ++j) { + if (pthread_condattr_destroy(&array[i].array[j])) return F_status_set_error(F_failure); } // for - } + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_condition_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for return F_okay; } diff --git a/level_0/f_thread/c/thread/condition_attribute.h b/level_0/f_thread/c/thread/condition_attribute.h index 67e8a69..e174977 100644 --- a/level_0/f_thread/c/thread/condition_attribute.h +++ b/level_0/f_thread/c/thread/condition_attribute.h @@ -22,7 +22,7 @@ extern "C" { #ifndef _di_f_thread_condition_attribute_t_ typedef pthread_condattr_t f_thread_condition_attribute_t; - #define f_thread_condition_attribute_t_initialize { 0 }; + #define f_thread_condition_attribute_t_initialize { 0 } #define macro_f_thread_condition_attribute_t_initialize_1(array, size, used) attribute diff --git a/level_0/f_thread/c/thread/condition_full.c b/level_0/f_thread/c/thread/condition_full.c new file mode 100644 index 0000000..bec2522 --- /dev/null +++ b/level_0/f_thread/c/thread/condition_full.c @@ -0,0 +1,124 @@ +#include "../thread.h" +#include "condition_full.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _di_f_thread_condition_fulls_delete_callback_ + f_status_t f_thread_condition_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_condition_full_t * const array = (f_thread_condition_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_cond_destroy(&array[i].condition); + + if (error) { + 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); + } + + if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_condition_fulls_delete_callback_ + +#ifndef _di_f_thread_condition_fulls_destroy_callback_ + f_status_t f_thread_condition_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_condition_full_t * const array = (f_thread_condition_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_cond_destroy(&array[i].condition); + + if (error) { + 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); + } + + if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_condition_fulls_destroy_callback_ + +#ifndef _di_f_thread_condition_fullss_delete_callback_ + f_status_t f_thread_condition_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_condition_fulls_t * const array = (f_thread_condition_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_cond_destroy(&array[i].array[j].condition); + + if (error) { + 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); + } + + if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_condition_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_condition_fullss_delete_callback_ + +#ifndef _di_f_thread_condition_fullss_destroy_callback_ + f_status_t f_thread_condition_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_condition_fulls_t * const array = (f_thread_condition_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_cond_destroy(&array[i].array[j].condition); + + if (error) { + 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); + } + + if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_condition_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_condition_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/c/thread/condition_full.h b/level_0/f_thread/c/thread/condition_full.h new file mode 100644 index 0000000..3c30a8f --- /dev/null +++ b/level_0/f_thread/c/thread/condition_full.h @@ -0,0 +1,199 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Defines common data to be used for/by POSIX thread related functionality. + * + * This is auto-included by thread.h and should not need to be explicitly included. + */ +#ifndef _F_thread_condition_full_h +#define _F_thread_condition_full_h + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * A structure of the condition and its associated attribute. + * + * Properties: + * - condition: The condition. + * - attribute: The associated attribute. + */ +#ifndef _di_f_thread_condition_full_t_ + typedef struct { + f_thread_condition_t condition; + f_thread_condition_attribute_t attribute; + } f_thread_condition_full_t; + + #define f_thread_condition_full_t_initialize { f_thread_condition_t_initialize, f_thread_condition_attribute_t_initialize } + + #define macro_f_thread_condition_full_t_initialize_1(condition, attribute) { condition, attribute } +#endif // _di_f_thread_condition_full_t_ + +/** + * An array of f_thread_condition_full_t. + * + * Properties: + * - array: The array of f_thread_condition_full_t. + * - size: Total amount of allocated space. + * - used: Total number of allocated spaces used. + */ +#ifndef _di_f_thread_condition_fulls_t_ + typedef struct { + f_thread_condition_full_t *array; + + f_number_unsigned_t size; + f_number_unsigned_t used; + } f_thread_condition_fulls_t; + + #define f_thread_condition_fulls_t_initialize { 0, 0, 0 } + + #define macro_f_thread_condition_fulls_t_initialize_1(array, size, used) { array, size, used } + #define macro_f_thread_condition_fulls_t_initialize_2(array, length) { array, length, length } +#endif // _di_f_thread_condition_fulls_t_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_condition_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_condition_fulls_delete_callback_ + extern f_status_t f_thread_condition_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_condition_fulls_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_condition_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_condition_fulls_destroy_callback_ + extern f_status_t f_thread_condition_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_condition_fulls_destroy_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_condition_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_condition_fullss_delete_callback_ + extern f_status_t f_thread_condition_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_condition_fullss_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_condition_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_condition_fullss_destroy_callback_ + extern f_status_t f_thread_condition_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_condition_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _F_thread_condition_full_h diff --git a/level_0/f_thread/c/thread/lock_attribute.c b/level_0/f_thread/c/thread/lock_attribute.c index 2ceb7cc..aca0fb2 100644 --- a/level_0/f_thread/c/thread/lock_attribute.c +++ b/level_0/f_thread/c/thread/lock_attribute.c @@ -8,22 +8,11 @@ extern "C" { #ifndef _di_f_thread_lock_attributes_delete_callback_ f_status_t f_thread_lock_attributes_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_lock_attribute_t * const array = (f_thread_lock_attribute_t *) void_array; - int error = 0; + f_thread_lock_attribute_t * const array = (f_thread_lock_attribute_t *) void_array; - for (f_number_unsigned_t i = start; i < stop; ++i) { - - error = pthread_rwlockattr_destroy(&array[i]); - - if (error) { - 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); - } - } // for - } + for (f_number_unsigned_t i = start; i < stop; ++i) { + if (pthread_rwlockattr_destroy(&array[i])) return F_status_set_error(F_failure); + } // for return F_okay; } @@ -32,22 +21,11 @@ extern "C" { #ifndef _di_f_thread_lock_attributes_destroy_callback_ f_status_t f_thread_lock_attributes_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_lock_attribute_t * const array = (f_thread_lock_attribute_t *) void_array; - int error = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_lock_attribute_t * const array = (f_thread_lock_attribute_t *) void_array; - error = pthread_rwlockattr_destroy(&array[i]); - - if (error) { - 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); - } - } // for - } + for (f_number_unsigned_t i = start; i < stop; ++i) { + if (pthread_rwlockattr_destroy(&array[i])) return F_status_set_error(F_failure); + } // for return F_okay; } @@ -56,31 +34,20 @@ extern "C" { #ifndef _di_f_thread_lock_attributess_delete_callback_ f_status_t f_thread_lock_attributess_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_lock_attributes_t * const array = (f_thread_lock_attributes_t *) void_array; - int error = 0; - f_number_unsigned_t j = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_lock_attributes_t * const array = (f_thread_lock_attributes_t *) void_array; + f_number_unsigned_t j = 0; - for (j = 0; j < array[i].size; ++j) { + for (f_number_unsigned_t i = start; i < stop; ++i) { - error = pthread_rwlockattr_destroy(&array[i].array[j]); - - if (error) { - 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); - } - } // for - - if (array[i].size && array[i].array) { - const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_lock_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); - if (F_status_is_error(status)) return status; - } + for (j = 0; j < array[i].size; ++j) { + if (pthread_rwlockattr_destroy(&array[i].array[j])) return F_status_set_error(F_failure); } // for - } + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_lock_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for return F_okay; } @@ -89,31 +56,20 @@ extern "C" { #ifndef _di_f_thread_lock_attributess_destroy_callback_ f_status_t f_thread_lock_attributess_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_lock_attributes_t * const array = (f_thread_lock_attributes_t *) void_array; - int error = 0; - f_number_unsigned_t j = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_lock_attributes_t * const array = (f_thread_lock_attributes_t *) void_array; + f_number_unsigned_t j = 0; - for (j = 0; j < array[i].size; ++j) { + for (f_number_unsigned_t i = start; i < stop; ++i) { - error = pthread_rwlockattr_destroy(&array[i].array[j]); - - if (error) { - 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); - } - } // for - - if (array[i].size && array[i].array) { - const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_lock_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); - if (F_status_is_error(status)) return status; - } + for (j = 0; j < array[i].size; ++j) { + if (pthread_rwlockattr_destroy(&array[i].array[j])) return F_status_set_error(F_failure); } // for - } + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_lock_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for return F_okay; } diff --git a/level_0/f_thread/c/thread/lock_full.c b/level_0/f_thread/c/thread/lock_full.c new file mode 100644 index 0000000..fad3af0 --- /dev/null +++ b/level_0/f_thread/c/thread/lock_full.c @@ -0,0 +1,124 @@ +#include "../thread.h" +#include "lock_full.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _di_f_thread_lock_fulls_delete_callback_ + f_status_t f_thread_lock_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_lock_full_t * const array = (f_thread_lock_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_rwlock_destroy(&array[i].lock); + + if (error) { + 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); + } + + if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_lock_fulls_delete_callback_ + +#ifndef _di_f_thread_lock_fulls_destroy_callback_ + f_status_t f_thread_lock_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_lock_full_t * const array = (f_thread_lock_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_rwlock_destroy(&array[i].lock); + + if (error) { + 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); + } + + if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_lock_fulls_destroy_callback_ + +#ifndef _di_f_thread_lock_fullss_delete_callback_ + f_status_t f_thread_lock_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_lock_fulls_t * const array = (f_thread_lock_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_rwlock_destroy(&array[i].array[j].lock); + + if (error) { + 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); + } + + if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_lock_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_lock_fullss_delete_callback_ + +#ifndef _di_f_thread_lock_fullss_destroy_callback_ + f_status_t f_thread_lock_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_lock_fulls_t * const array = (f_thread_lock_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_rwlock_destroy(&array[i].array[j].lock); + + if (error) { + 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); + } + + if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_lock_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_lock_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/c/thread/lock_full.h b/level_0/f_thread/c/thread/lock_full.h new file mode 100644 index 0000000..9c9522a --- /dev/null +++ b/level_0/f_thread/c/thread/lock_full.h @@ -0,0 +1,199 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Defines common data to be used for/by POSIX thread related functionality. + * + * This is auto-included by thread.h and should not need to be explicitly included. + */ +#ifndef _F_thread_lock_full_h +#define _F_thread_lock_full_h + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * A structure of the lock and its associated attribute. + * + * Properties: + * - lock: The lock. + * - attribute: The associated attribute. + */ +#ifndef _di_f_thread_lock_full_t_ + typedef struct { + f_thread_lock_t lock; + f_thread_lock_attribute_t attribute; + } f_thread_lock_full_t; + + #define f_thread_lock_full_t_initialize { f_thread_lock_t_initialize, f_thread_lock_attribute_t_initialize } + + #define macro_f_thread_lock_full_t_initialize_1(lock, attribute) { lock, attribute } +#endif // _di_f_thread_lock_full_t_ + +/** + * An array of f_thread_lock_full_t. + * + * Properties: + * - array: The array of f_thread_lock_full_t. + * - size: Total amount of allocated space. + * - used: Total number of allocated spaces used. + */ +#ifndef _di_f_thread_lock_fulls_t_ + typedef struct { + f_thread_lock_full_t *array; + + f_number_unsigned_t size; + f_number_unsigned_t used; + } f_thread_lock_fulls_t; + + #define f_thread_lock_fulls_t_initialize { 0, 0, 0 } + + #define macro_f_thread_lock_fulls_t_initialize_1(array, size, used) { array, size, used } + #define macro_f_thread_lock_fulls_t_initialize_2(array, length) { array, length, length } +#endif // _di_f_thread_lock_fulls_t_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_lock_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_lock_fulls_delete_callback_ + extern f_status_t f_thread_lock_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_lock_fulls_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_lock_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_lock_fulls_destroy_callback_ + extern f_status_t f_thread_lock_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_lock_fulls_destroy_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_lock_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_lock_fullss_delete_callback_ + extern f_status_t f_thread_lock_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_lock_fullss_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_lock_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_lock_fullss_destroy_callback_ + extern f_status_t f_thread_lock_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_lock_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _F_thread_lock_full_h diff --git a/level_0/f_thread/c/thread/mutex_attribute.c b/level_0/f_thread/c/thread/mutex_attribute.c index 583ec5e..75b54b5 100644 --- a/level_0/f_thread/c/thread/mutex_attribute.c +++ b/level_0/f_thread/c/thread/mutex_attribute.c @@ -8,22 +8,11 @@ extern "C" { #ifndef _di_f_thread_mutex_attributes_delete_callback_ f_status_t f_thread_mutex_attributes_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_mutex_attribute_t * const array = (f_thread_mutex_attribute_t *) void_array; - int error = 0; + f_thread_mutex_attribute_t * const array = (f_thread_mutex_attribute_t *) void_array; - for (f_number_unsigned_t i = start; i < stop; ++i) { - - error = pthread_mutexattr_destroy(&array[i]); - - if (error) { - 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); - } - } // for - } + for (f_number_unsigned_t i = start; i < stop; ++i) { + if (pthread_mutexattr_destroy(&array[i])) return F_status_set_error(F_failure); + } // for return F_okay; } @@ -32,22 +21,11 @@ extern "C" { #ifndef _di_f_thread_mutex_attributes_destroy_callback_ f_status_t f_thread_mutex_attributes_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_mutex_attribute_t * const array = (f_thread_mutex_attribute_t *) void_array; - int error = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_mutex_attribute_t * const array = (f_thread_mutex_attribute_t *) void_array; - error = pthread_mutexattr_destroy(&array[i]); - - if (error) { - 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); - } - } // for - } + for (f_number_unsigned_t i = start; i < stop; ++i) { + if (pthread_mutexattr_destroy(&array[i])) return F_status_set_error(F_failure); + } // for return F_okay; } @@ -56,31 +34,20 @@ extern "C" { #ifndef _di_f_thread_mutex_attributess_delete_callback_ f_status_t f_thread_mutex_attributess_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_mutex_attributes_t * const array = (f_thread_mutex_attributes_t *) void_array; - int error = 0; - f_number_unsigned_t j = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_mutex_attributes_t * const array = (f_thread_mutex_attributes_t *) void_array; + f_number_unsigned_t j = 0; - for (j = 0; j < array[i].size; ++j) { + for (f_number_unsigned_t i = start; i < stop; ++i) { - error = pthread_mutexattr_destroy(&array[i].array[j]); - - if (error) { - 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); - } - } // for - - if (array[i].size && array[i].array) { - const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_mutex_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); - if (F_status_is_error(status)) return status; - } + for (j = 0; j < array[i].size; ++j) { + if (pthread_mutexattr_destroy(&array[i].array[j])) return F_status_set_error(F_failure); } // for - } + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_mutex_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for return F_okay; } @@ -89,31 +56,20 @@ extern "C" { #ifndef _di_f_thread_mutex_attributess_destroy_callback_ f_status_t f_thread_mutex_attributess_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { - { - f_thread_mutex_attributes_t * const array = (f_thread_mutex_attributes_t *) void_array; - int error = 0; - f_number_unsigned_t j = 0; - - for (f_number_unsigned_t i = start; i < stop; ++i) { + f_thread_mutex_attributes_t * const array = (f_thread_mutex_attributes_t *) void_array; + f_number_unsigned_t j = 0; - for (j = 0; j < array[i].size; ++j) { + for (f_number_unsigned_t i = start; i < stop; ++i) { - error = pthread_mutexattr_destroy(&array[i].array[j]); - - if (error) { - 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); - } - } // for - - if (array[i].size && array[i].array) { - const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_mutex_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); - if (F_status_is_error(status)) return status; - } + for (j = 0; j < array[i].size; ++j) { + if (pthread_mutexattr_destroy(&array[i].array[j])) return F_status_set_error(F_failure); } // for - } + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_mutex_attribute_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for return F_okay; } diff --git a/level_0/f_thread/c/thread/mutex_full.c b/level_0/f_thread/c/thread/mutex_full.c new file mode 100644 index 0000000..6665fe6 --- /dev/null +++ b/level_0/f_thread/c/thread/mutex_full.c @@ -0,0 +1,124 @@ +#include "../thread.h" +#include "mutex_full.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _di_f_thread_mutex_fulls_delete_callback_ + f_status_t f_thread_mutex_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_mutex_full_t * const array = (f_thread_mutex_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_mutex_destroy(&array[i].mutex); + + if (error) { + 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); + } + + if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_mutex_fulls_delete_callback_ + +#ifndef _di_f_thread_mutex_fulls_destroy_callback_ + f_status_t f_thread_mutex_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_mutex_full_t * const array = (f_thread_mutex_full_t *) void_array; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + error = pthread_mutex_destroy(&array[i].mutex); + + if (error) { + 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); + } + + if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure); + } // for + + return F_okay; + } +#endif // _di_f_thread_mutex_fulls_destroy_callback_ + +#ifndef _di_f_thread_mutex_fullss_delete_callback_ + f_status_t f_thread_mutex_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_mutex_fulls_t * const array = (f_thread_mutex_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_mutex_destroy(&array[i].array[j].mutex); + + if (error) { + 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); + } + + if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_resize(0, sizeof(f_thread_mutex_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_mutex_fullss_delete_callback_ + +#ifndef _di_f_thread_mutex_fullss_destroy_callback_ + f_status_t f_thread_mutex_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const void_array) { + + f_thread_mutex_fulls_t * const array = (f_thread_mutex_fulls_t *) void_array; + f_number_unsigned_t j = 0; + int error = 0; + + for (f_number_unsigned_t i = start; i < stop; ++i) { + + for (j = 0; j < array[i].size; ++j) { + + error = pthread_mutex_destroy(&array[i].array[j].mutex); + + if (error) { + 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); + } + + if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure); + } // for + + if (array[i].size && array[i].array) { + const f_status_t status = f_memory_array_adjust(0, sizeof(f_thread_mutex_full_t), (void **) &array[i].array, &array[i].used, &array[i].size); + if (F_status_is_error(status)) return status; + } + } // for + + return F_okay; + } +#endif // _di_f_thread_mutex_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/c/thread/mutex_full.h b/level_0/f_thread/c/thread/mutex_full.h new file mode 100644 index 0000000..46fde17 --- /dev/null +++ b/level_0/f_thread/c/thread/mutex_full.h @@ -0,0 +1,199 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Defines common data to be used for/by POSIX thread related functionality. + * + * This is auto-included by thread.h and should not need to be explicitly included. + */ +#ifndef _F_thread_mutex_full_h +#define _F_thread_mutex_full_h + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * A structure of the mutex and its associated attribute. + * + * Properties: + * - mutex: The mutex. + * - attribute: The associated attribute. + */ +#ifndef _di_f_thread_mutex_full_t_ + typedef struct { + f_thread_mutex_t mutex; + f_thread_mutex_attribute_t attribute; + } f_thread_mutex_full_t; + + #define f_thread_mutex_full_t_initialize { f_thread_mutex_t_initialize, f_thread_mutex_attribute_t_initialize } + + #define macro_f_thread_mutex_full_t_initialize_1(mutex, attribute) { mutex, attribute } +#endif // _di_f_thread_mutex_full_t_ + +/** + * An array of f_thread_mutex_full_t. + * + * Properties: + * - array: The array of f_thread_mutex_full_t. + * - size: Total amount of allocated space. + * - used: Total number of allocated spaces used. + */ +#ifndef _di_f_thread_mutex_fulls_t_ + typedef struct { + f_thread_mutex_full_t *array; + + f_number_unsigned_t size; + f_number_unsigned_t used; + } f_thread_mutex_fulls_t; + + #define f_thread_mutex_fulls_t_initialize { 0, 0, 0 } + + #define macro_f_thread_mutex_fulls_t_initialize_1(array, size, used) { array, size, used } + #define macro_f_thread_mutex_fulls_t_initialize_2(array, length) { array, length, length } +#endif // _di_f_thread_mutex_fulls_t_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_mutex_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_mutex_fulls_delete_callback_ + extern f_status_t f_thread_mutex_fulls_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_mutex_fulls_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_mutex_fulls_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_mutex_fulls_destroy_callback_ + extern f_status_t f_thread_mutex_fulls_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_mutex_fulls_destroy_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_resize() for an f_thread_mutex_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_mutex_fullss_delete_callback_ + extern f_status_t f_thread_mutex_fullss_delete_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_mutex_fullss_delete_callback_ + +/** + * A callback intended to be passed to f_memory_arrays_adjust() for an f_thread_mutex_fullss_t structure. + * + * This is only called when shrinking the array and generally should perform deallocations. + * + * This does not do parameter checking. + * + * @param start + * The inclusive start position in the array to start deleting. + * @param stop + * The exclusive stop position in the array to stop deleting. + * @param array + * The array structure to delete all values of. + * + * Must not be NULL. + * + * @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. + * + * 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() + */ +#ifndef _di_f_thread_mutex_fullss_destroy_callback_ + extern f_status_t f_thread_mutex_fullss_destroy_callback(const f_number_unsigned_t start, const f_number_unsigned_t stop, void * const array); +#endif // _di_f_thread_mutex_fullss_destroy_callback_ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _F_thread_mutex_full_h diff --git a/level_0/f_thread/data/build/settings b/level_0/f_thread/data/build/settings index 0fcfd2f..1eb4269 100644 --- a/level_0/f_thread/data/build/settings +++ b/level_0/f_thread/data/build/settings @@ -41,9 +41,9 @@ build_libraries_shared-individual -lf_memory -lf_string build_libraries_static -l:libc.a build_libraries_static-individual -l:libf_memory.a -l:libf_string.a -build_sources_library thread.c thread/attribute.c thread/barrier.c thread/barrier_attribute.c thread/condition.c thread/condition_attribute.c thread/id.c thread/key.c thread/lock.c thread/lock_attribute.c thread/mutex.c thread/mutex_attribute.c thread/once.c thread/semaphore.c thread/set.c thread/spin.c +build_sources_library thread.c thread/attribute.c thread/barrier.c thread/barrier_attribute.c thread/barrier_full.c thread/condition.c thread/condition_attribute.c thread/condition_full.c thread/id.c thread/key.c thread/lock.c thread/lock_attribute.c thread/lock_full.c thread/mutex.c thread/mutex_attribute.c thread/mutex_full.c thread/once.c thread/semaphore.c thread/set.c thread/spin.c -build_sources_headers thread.h thread/attribute.h thread/barrier.h thread/barrier_attribute.h thread/condition.h thread/condition_attribute.h thread/id.h thread/key.h thread/lock.h thread/lock_attribute.h thread/mutex.h thread/mutex_attribute.h thread/once.h thread/semaphore.h thread/set.h thread/spin.h +build_sources_headers thread.h thread/attribute.h thread/barrier.h thread/barrier_attribute.h thread/barrier_full.h thread/condition.h thread/condition_attribute.h thread/condition_full.h thread/id.h thread/key.h thread/lock.h thread/lock_attribute.h thread/lock_full.h thread/mutex.h thread/mutex_attribute.h thread/mutex_full.h thread/once.h thread/semaphore.h thread/set.h thread/spin.h build_script yes build_shared yes diff --git a/level_0/f_thread/data/build/settings-mocks b/level_0/f_thread/data/build/settings-mocks index 1f7f2f5..6301397 100644 --- a/level_0/f_thread/data/build/settings-mocks +++ b/level_0/f_thread/data/build/settings-mocks @@ -30,10 +30,10 @@ build_language c build_libraries -pthread -lc build_libraries-individual -lf_memory -lf_string -build_sources_library thread.c thread/attribute.c thread/barrier.c thread/barrier_attribute.c thread/condition.c thread/condition_attribute.c thread/id.c thread/key.c thread/lock.c thread/lock_attribute.c thread/mutex.c thread/mutex_attribute.c thread/once.c thread/semaphore.c thread/set.c thread/spin.c +build_sources_library thread.c thread/attribute.c thread/barrier.c thread/barrier_attribute.c thread/barrier_full.c thread/condition.c thread/condition_attribute.c thread/condition_full.c thread/id.c thread/key.c thread/lock.c thread/lock_attribute.c thread/lock_full.c thread/mutex.c thread/mutex_attribute.c thread/mutex_full.c thread/once.c thread/semaphore.c thread/set.c thread/spin.c build_sources_library ../../tests/unit/c/mock-thread.c -build_sources_headers thread.h thread/attribute.h thread/barrier.h thread/barrier_attribute.h thread/condition.h thread/condition_attribute.h thread/id.h thread/key.h thread/lock.h thread/lock_attribute.h thread/mutex.h thread/mutex_attribute.h thread/once.h thread/semaphore.h thread/set.h thread/spin.h +build_sources_headers thread.h thread/attribute.h thread/barrier.h thread/barrier_attribute.h thread/barrier_full.h thread/condition.h thread/condition_attribute.h thread/condition_full.h thread/id.h thread/key.h thread/lock.h thread/lock_attribute.h thread/lock_full.h thread/mutex.h thread/mutex_attribute.h thread/mutex_full.h thread/once.h thread/semaphore.h thread/set.h thread/spin.h build_script yes build_shared yes diff --git a/level_0/f_thread/data/build/settings-tests b/level_0/f_thread/data/build/settings-tests index 5954e88..637c907 100644 --- a/level_0/f_thread/data/build/settings-tests +++ b/level_0/f_thread/data/build/settings-tests @@ -25,20 +25,6 @@ build_language c build_libraries -lc -lcmocka build_libraries-individual -lf_memory -lf_string -lf_thread -build_sources_program test-thread-attributes_destroy_callback.c test-thread-attributes_delete_callback.c -build_sources_program test-thread-barriers_destroy_callback.c test-thread-barriers_delete_callback.c -build_sources_program test-thread-barrier_attributes_destroy_callback.c test-thread-barrier_attributes_delete_callback.c -build_sources_program test-thread-conditions_destroy_callback.c test-thread-conditions_delete_callback.c -build_sources_program test-thread-condition_attributes_destroy_callback.c test-thread-condition_attributes_delete_callback.c -build_sources_program test-thread-keys_destroy_callback.c test-thread-keys_delete_callback.c -build_sources_program test-thread-locks_destroy_callback.c test-thread-locks_delete_callback.c -build_sources_program test-thread-lock_attributes_destroy_callback.c test-thread-lock_attributes_delete_callback.c -build_sources_program test-thread-mutexs_destroy_callback.c test-thread-mutexs_delete_callback.c -build_sources_program test-thread-mutex_attributes_destroy_callback.c test-thread-mutex_attributes_delete_callback.c -build_sources_program test-thread-semaphores_destroy_callback.c test-thread-semaphores_delete_callback.c -build_sources_program test-thread-sets_destroy_callback.c test-thread-sets_delete_callback.c -build_sources_program test-thread-spins_destroy_callback.c test-thread-spins_delete_callback.c - build_sources_program test-thread-at_fork.c build_sources_program test-thread-attribute_affinity_get.c test-thread-attribute_affinity_set.c build_sources_program test-thread-attribute_concurrency_get.c test-thread-attribute_concurrency_set.c @@ -52,9 +38,14 @@ build_sources_program test-thread-attribute_scheduler_policy_get.c test-thread-a build_sources_program test-thread-attribute_scope_get.c test-thread-attribute_scope_set.c build_sources_program test-thread-attribute_stack_get.c test-thread-attribute_stack_set.c build_sources_program test-thread-attribute_stack_size_get.c test-thread-attribute_stack_size_set.c +build_sources_program test-thread-attributes_destroy_callback.c test-thread-attributes_delete_callback.c build_sources_program test-thread-barrier_attribute_create.c test-thread-barrier_attribute_delete.c build_sources_program test-thread-barrier_attribute_shared_get.c test-thread-barrier_attribute_shared_set.c +build_sources_program test-thread-barrier_attributes_destroy_callback.c test-thread-barrier_attributes_delete_callback.c build_sources_program test-thread-barrier_create.c test-thread-barrier_delete.c +build_sources_program test-thread-barrier_full_delete.c +build_sources_program test-thread-barrier_fulls_destroy_callback.c test-thread-barrier_fulls_delete_callback.c +build_sources_program test-thread-barriers_destroy_callback.c test-thread-barriers_delete_callback.c build_sources_program test-thread-barrier_wait.c build_sources_program test-thread-caller.c build_sources_program test-thread-cancel.c @@ -66,20 +57,29 @@ build_sources_program test-thread-compare.c build_sources_program test-thread-condition_attribute_clock_get.c test-thread-condition_attribute_clock_set.c build_sources_program test-thread-condition_attribute_create.c test-thread-condition_attribute_delete.c build_sources_program test-thread-condition_attribute_shared_get.c test-thread-condition_attribute_shared_set.c +build_sources_program test-thread-condition_attributes_destroy_callback.c test-thread-condition_attributes_delete_callback.c build_sources_program test-thread-condition_create.c test-thread-condition_delete.c +build_sources_program test-thread-condition_full_delete.c +build_sources_program test-thread-condition_fulls_destroy_callback.c test-thread-condition_fulls_delete_callback.c build_sources_program test-thread-condition_signal.c test-thread-condition_signal_all.c build_sources_program test-thread-condition_wait.c test-thread-condition_wait_timed.c +build_sources_program test-thread-conditions_destroy_callback.c test-thread-conditions_delete_callback.c build_sources_program test-thread-create.c build_sources_program test-thread-detach.c build_sources_program test-thread-exit.c build_sources_program test-thread-join.c test-thread-join_try.c test-thread-join_timed.c build_sources_program test-thread-key_create.c test-thread-key_delete.c build_sources_program test-thread-key_get.c test-thread-key_set.c +build_sources_program test-thread-keys_destroy_callback.c test-thread-keys_delete_callback.c build_sources_program test-thread-lock_attribute_create.c test-thread-lock_attribute_delete.c build_sources_program test-thread-lock_attribute_shared_get.c test-thread-lock_attribute_shared_set.c +build_sources_program test-thread-lock_attributes_destroy_callback.c test-thread-lock_attributes_delete_callback.c build_sources_program test-thread-lock_create.c test-thread-lock_delete.c +build_sources_program test-thread-lock_full_delete.c +build_sources_program test-thread-lock_fulls_destroy_callback.c test-thread-lock_fulls_delete_callback.c build_sources_program test-thread-lock_read.c test-thread-lock_read_timed.c test-thread-lock_read_try.c build_sources_program test-thread-lock_write.c test-thread-lock_write_timed.c test-thread-lock_write_try.c +build_sources_program test-thread-locks_destroy_callback.c test-thread-locks_delete_callback.c build_sources_program test-thread-mutex_attribute_create.c test-thread-mutex_attribute_delete.c build_sources_program test-thread-mutex_attribute_priority_ceiling_get.c test-thread-mutex_attribute_priority_ceiling_set.c build_sources_program test-thread-mutex_attribute_robust_get.c test-thread-mutex_attribute_robust_set.c @@ -89,19 +89,26 @@ build_sources_program test-thread-mutex_attribute_protocol_get.c test-thread-mut build_sources_program test-thread-mutex_consistent.c build_sources_program test-thread-mutex_create.c test-thread-mutex_delete.c build_sources_program test-thread-mutex_lock.c test-thread-mutex_lock_timed.c test-thread-mutex_lock_try.c -build_sources_program test-thread-scheduler_parameter_get.c test-thread-scheduler_parameter_set.c -build_sources_program test-thread-scheduler_priority_set.c -build_sources_program test-thread-signal_mask.c test-thread-signal_queue.c test-thread-signal_write.c -build_sources_program test-thread-spin_create.c test-thread-spin_delete.c -build_sources_program test-thread-spin_lock.c test-thread-spin_lock_try.c test-thread-spin_unlock.c +build_sources_program test-thread-mutex_attributes_destroy_callback.c test-thread-mutex_attributes_delete_callback.c +build_sources_program test-thread-mutex_full_delete.c +build_sources_program test-thread-mutex_fulls_destroy_callback.c test-thread-mutex_fulls_delete_callback.c build_sources_program test-thread-mutex_priority_ceiling_get.c test-thread-mutex_priority_ceiling_set.c +build_sources_program test-thread-mutexs_destroy_callback.c test-thread-mutexs_delete_callback.c build_sources_program test-thread-name_get.c test-thread-name_set.c build_sources_program test-thread-once.c +build_sources_program test-thread-scheduler_parameter_get.c test-thread-scheduler_parameter_set.c +build_sources_program test-thread-scheduler_priority_set.c build_sources_program test-thread-semaphore_create.c test-thread-semaphore_delete.c build_sources_program test-thread-semaphore_file_open.c test-thread-semaphore_file_close.c test-thread-semaphore_file_delete.c build_sources_program test-thread-semaphore_lock.c test-thread-semaphore_lock_timed.c test-thread-semaphore_lock_try.c build_sources_program test-thread-semaphore_unlock.c build_sources_program test-thread-semaphore_value_get.c +build_sources_program test-thread-semaphores_destroy_callback.c test-thread-semaphores_delete_callback.c +build_sources_program test-thread-sets_destroy_callback.c test-thread-sets_delete_callback.c +build_sources_program test-thread-signal_mask.c test-thread-signal_queue.c test-thread-signal_write.c +build_sources_program test-thread-spin_create.c test-thread-spin_delete.c +build_sources_program test-thread-spin_lock.c test-thread-spin_lock_try.c test-thread-spin_unlock.c +build_sources_program test-thread-spins_destroy_callback.c test-thread-spins_delete_callback.c build_sources_program test-thread.c 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 new file mode 100644 index 0000000..f2d73f5 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c @@ -0,0 +1,72 @@ +#include "test-thread.h" +#include "test-thread-barrier_full_delete.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_barrier_full_delete__fails(void **state) { + + f_thread_barrier_full_t full = f_thread_barrier_full_t_initialize; + + int errnos[] = { + EBUSY, + EINVAL, + mock_errno_generic, + }; + + f_status_t statuss[] = { + F_busy, + F_parameter, + F_failure, + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_barrier_destroy, true); + will_return(__wrap_pthread_barrier_destroy, errnos[i]); + + const f_status_t status = f_thread_barrier_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_barrier_destroy, false); + will_return(__wrap_pthread_barrierattr_destroy, true); + will_return(__wrap_pthread_barrierattr_destroy, errnos[i]); + + const f_status_t status = f_thread_barrier_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } // for +} + +void test__f_thread_barrier_full_delete__parameter_checking(void **state) { + + { + const f_status_t status = f_thread_barrier_full_delete(0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_thread_barrier_full_delete__works(void **state) { + + f_thread_barrier_full_t full = f_thread_barrier_full_t_initialize; + + { + will_return(__wrap_pthread_barrier_destroy, false); + will_return(__wrap_pthread_barrierattr_destroy, false); + + const f_status_t status = f_thread_barrier_full_delete(&full); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.h b/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.h new file mode 100644 index 0000000..5b074e6 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the thread project. + */ +#ifndef _TEST__F_thread__barrier_full_delete_h +#define _TEST__F_thread__barrier_full_delete_h + +/** + * Test that function fails. + * + * @see f_thread_barrier_full_delete() + */ +extern void test__f_thread_barrier_full_delete__fails(void **state); + +/** + * Test that parameter checking works as expected. + * + * @see f_thread_barrier_full_delete() + */ +extern void test__f_thread_barrier_full_delete__parameter_checking(void **state); + +/** + * Test that function works. + * + * @see f_thread_barrier_full_delete() + */ +extern void test__f_thread_barrier_full_delete__works(void **state); + +#endif // _TEST__F_thread__barrier_full_delete_h 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 new file mode 100644 index 0000000..61a972f --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-barrier_fulls_delete_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_barrier_fulls_delete_callback__fails(void **state) { + + f_thread_barrier_full_t data = f_thread_barrier_full_t_initialize; + f_thread_barrier_full_t data_array[] = { data }; + f_thread_barrier_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_barrier_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + mock_errno_generic, + }; + + f_status_t statuss[] = { + F_busy, + F_parameter, + F_failure, + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_barrier_destroy, true); + will_return(__wrap_pthread_barrier_destroy, errnos[i]); + + 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])); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_barrier_destroy, false); + will_return(__wrap_pthread_barrierattr_destroy, true); + will_return(__wrap_pthread_barrierattr_destroy, errnos[i]); + + 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])); + } // for +} + +void test__f_thread_barrier_fulls_delete_callback__works(void **state) { + + f_thread_barrier_full_t data = f_thread_barrier_full_t_initialize; + f_thread_barrier_full_t data_array[] = { data }; + f_thread_barrier_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_barrier_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_barrier_destroy, false); + will_return(__wrap_pthread_barrierattr_destroy, false); + + const f_status_t status = f_thread_barrier_fulls_delete_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.h b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.h new file mode 100644 index 0000000..8e7ac6a --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__barrier_fulls_delete_callback +#define _TEST__F_thread__barrier_fulls_delete_callback + +/** + * Test that the function fails. + * + * @see f_thread_barrier_fulls_delete_callback_() + */ +extern void test__f_thread_barrier_fulls_delete_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_barrier_fulls_delete_callback_() + */ +extern void test__f_thread_barrier_fulls_delete_callback__works(void **state); + +#endif // _TEST__F_thread__barrier_fulls_delete_callback 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 new file mode 100644 index 0000000..02ce59d --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-barrier_fulls_destroy_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_barrier_fulls_destroy_callback__fails(void **state) { + + f_thread_barrier_full_t data = f_thread_barrier_full_t_initialize; + f_thread_barrier_full_t data_array[] = { data }; + f_thread_barrier_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_barrier_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + mock_errno_generic, + }; + + f_status_t statuss[] = { + F_busy, + F_parameter, + F_failure, + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_barrier_destroy, true); + will_return(__wrap_pthread_barrier_destroy, errnos[i]); + + 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])); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_barrier_destroy, false); + will_return(__wrap_pthread_barrierattr_destroy, true); + will_return(__wrap_pthread_barrierattr_destroy, errnos[i]); + + 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])); + } // for +} + +void test__f_thread_barrier_fulls_destroy_callback__works(void **state) { + + f_thread_barrier_full_t data = f_thread_barrier_full_t_initialize; + f_thread_barrier_full_t data_array[] = { data }; + f_thread_barrier_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_barrier_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_barrier_destroy, false); + will_return(__wrap_pthread_barrierattr_destroy, false); + + const f_status_t status = f_thread_barrier_fulls_destroy_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.h b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.h new file mode 100644 index 0000000..320d7d8 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__barrier_fulls_destroy_callback +#define _TEST__F_thread__barrier_fulls_destroy_callback + +/** + * Test that the function fails. + * + * @see f_thread_barrier_fulls_destroy_callback_() + */ +extern void test__f_thread_barrier_fulls_destroy_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_barrier_fulls_destroy_callback_() + */ +extern void test__f_thread_barrier_fulls_destroy_callback__works(void **state); + +#endif // _TEST__F_thread__barrier_fulls_destroy_callback diff --git a/level_0/f_thread/tests/unit/c/test-thread-barriers_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barriers_delete_callback.c index 2ce66f5..789df4c 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-barriers_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-barriers_delete_callback.c @@ -25,6 +25,7 @@ void test__f_thread_barriers_delete_callback__fails(void **state) { }; for (uint8_t i = 0; i < 3; ++i) { + will_return(__wrap_pthread_barrier_destroy, true); will_return(__wrap_pthread_barrier_destroy, errnos[i]); diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_attribute_delete.c b/level_0/f_thread/tests/unit/c/test-thread-condition_attribute_delete.c index 82bee1c..38ddb23 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_attribute_delete.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_attribute_delete.c @@ -10,18 +10,14 @@ void test__f_thread_condition_attribute_delete__fails(void **state) { f_thread_condition_attribute_t attribute = f_thread_condition_attribute_t_initialize; int errnos[] = { - EBUSY, - EINVAL, mock_errno_generic, }; f_status_t statuss[] = { - F_busy, - F_parameter, F_failure, }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_condattr_destroy, true); will_return(__wrap_pthread_condattr_destroy, errnos[i]); diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_delete_callback.c index e6df924..c0c70b4 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_delete_callback.c @@ -13,18 +13,14 @@ void test__f_thread_condition_attributes_delete_callback__fails(void **state) { f_thread_condition_attributes_t datass_array[] = { datas }; int errnos[] = { - EBUSY, - EINVAL, 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), }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_condattr_destroy, true); will_return(__wrap_pthread_condattr_destroy, errnos[i]); diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_destroy_callback.c index 869d1d9..d8af3a1 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_attributes_destroy_callback.c @@ -13,18 +13,14 @@ void test__f_thread_condition_attributes_destroy_callback__fails(void **state) { f_thread_condition_attributes_t datass_array[] = { datas }; int errnos[] = { - EBUSY, - EINVAL, 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), }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_condattr_destroy, true); will_return(__wrap_pthread_condattr_destroy, errnos[i]); 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 new file mode 100644 index 0000000..7e40b37 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c @@ -0,0 +1,72 @@ +#include "test-thread.h" +#include "test-thread-condition_full_delete.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_condition_full_delete__fails(void **state) { + + f_thread_condition_full_t full = f_thread_condition_full_t_initialize; + + int errnos[] = { + EBUSY, + EINVAL, + mock_errno_generic, + }; + + f_status_t statuss[] = { + F_busy, + F_parameter, + F_failure, + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_cond_destroy, true); + will_return(__wrap_pthread_cond_destroy, errnos[i]); + + const f_status_t status = f_thread_condition_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_cond_destroy, false); + will_return(__wrap_pthread_condattr_destroy, true); + will_return(__wrap_pthread_condattr_destroy, errnos[i]); + + const f_status_t status = f_thread_condition_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } // for +} + +void test__f_thread_condition_full_delete__parameter_checking(void **state) { + + { + const f_status_t status = f_thread_condition_full_delete(0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_thread_condition_full_delete__works(void **state) { + + f_thread_condition_full_t full = f_thread_condition_full_t_initialize; + + { + will_return(__wrap_pthread_cond_destroy, false); + will_return(__wrap_pthread_condattr_destroy, false); + + const f_status_t status = f_thread_condition_full_delete(&full); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.h b/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.h new file mode 100644 index 0000000..8a92213 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the thread project. + */ +#ifndef _TEST__F_thread__condition_full_delete_h +#define _TEST__F_thread__condition_full_delete_h + +/** + * Test that function fails. + * + * @see f_thread_condition_full_delete() + */ +extern void test__f_thread_condition_full_delete__fails(void **state); + +/** + * Test that parameter checking works as expected. + * + * @see f_thread_condition_full_delete() + */ +extern void test__f_thread_condition_full_delete__parameter_checking(void **state); + +/** + * Test that function works. + * + * @see f_thread_condition_full_delete() + */ +extern void test__f_thread_condition_full_delete__works(void **state); + +#endif // _TEST__F_thread__condition_full_delete_h 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 new file mode 100644 index 0000000..7597a45 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-condition_fulls_delete_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_condition_fulls_delete_callback__fails(void **state) { + + f_thread_condition_full_t data = f_thread_condition_full_t_initialize; + f_thread_condition_full_t data_array[] = { data }; + f_thread_condition_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_condition_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + 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), + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_cond_destroy, true); + will_return(__wrap_pthread_cond_destroy, errnos[i]); + + const f_status_t status = f_thread_condition_fulls_delete_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_cond_destroy, false); + will_return(__wrap_pthread_condattr_destroy, true); + will_return(__wrap_pthread_condattr_destroy, errnos[i]); + + const f_status_t status = f_thread_condition_fulls_delete_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for +} + +void test__f_thread_condition_fulls_delete_callback__works(void **state) { + + f_thread_condition_full_t data = f_thread_condition_full_t_initialize; + f_thread_condition_full_t data_array[] = { data }; + f_thread_condition_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_condition_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_cond_destroy, false); + will_return(__wrap_pthread_condattr_destroy, false); + + const f_status_t status = f_thread_condition_fulls_delete_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.h b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.h new file mode 100644 index 0000000..ea0253e --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__condition_fulls_delete_callback +#define _TEST__F_thread__condition_fulls_delete_callback + +/** + * Test that the function fails. + * + * @see f_thread_condition_fulls_delete_callback() + */ +extern void test__f_thread_condition_fulls_delete_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_condition_fulls_delete_callback() + */ +extern void test__f_thread_condition_fulls_delete_callback__works(void **state); + +#endif // _TEST__F_thread__condition_fulls_delete_callback 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 new file mode 100644 index 0000000..bf7d092 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-condition_fulls_destroy_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_condition_fulls_destroy_callback__fails(void **state) { + + f_thread_condition_full_t data = f_thread_condition_full_t_initialize; + f_thread_condition_full_t data_array[] = { data }; + f_thread_condition_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_condition_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + 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), + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_cond_destroy, true); + will_return(__wrap_pthread_cond_destroy, errnos[i]); + + const f_status_t status = f_thread_condition_fulls_destroy_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_cond_destroy, false); + will_return(__wrap_pthread_condattr_destroy, true); + will_return(__wrap_pthread_condattr_destroy, errnos[i]); + + const f_status_t status = f_thread_condition_fulls_destroy_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for +} + +void test__f_thread_condition_fulls_destroy_callback__works(void **state) { + + f_thread_condition_full_t data = f_thread_condition_full_t_initialize; + f_thread_condition_full_t data_array[] = { data }; + f_thread_condition_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_condition_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_cond_destroy, false); + will_return(__wrap_pthread_condattr_destroy, false); + + const f_status_t status = f_thread_condition_fulls_destroy_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.h b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.h new file mode 100644 index 0000000..8614803 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__condition_fulls_destroy_callback +#define _TEST__F_thread__condition_fulls_destroy_callback + +/** + * Test that the function fails. + * + * @see f_thread_condition_fulls_destroy_callback() + */ +extern void test__f_thread_condition_fulls_destroy_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_condition_fulls_destroy_callback() + */ +extern void test__f_thread_condition_fulls_destroy_callback__works(void **state); + +#endif // _TEST__F_thread__condition_fulls_destroy_callback diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.c b/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.c index bff1dab..d1982c1 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.c @@ -10,18 +10,14 @@ void test__f_thread_lock_attribute_delete__fails(void **state) { f_thread_lock_attribute_t attribute = f_thread_lock_attribute_t_initialize; int errnos[] = { - EBUSY, - EINVAL, mock_errno_generic, }; f_status_t statuss[] = { - F_busy, - F_parameter, F_failure, }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_rwlockattr_destroy, true); will_return(__wrap_pthread_rwlockattr_destroy, errnos[i]); diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.h b/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.h index 7a8c666..b6c8958 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.h +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_attribute_delete.h @@ -11,6 +11,13 @@ #define _TEST__F_thread__lock_attribute_delete_h /** + * Test that function fails. + * + * @see f_thread_lock_attribute_delete() + */ +extern void test__f_thread_lock_attribute_delete__fails(void **state); + +/** * Test that parameter checking works as expected. * * @see f_thread_lock_attribute_delete() diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_delete_callback.c index a614212..47bfe42 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_delete_callback.c @@ -13,18 +13,14 @@ void test__f_thread_lock_attributes_delete_callback__fails(void **state) { f_thread_lock_attributes_t datass_array[] = { datas }; int errnos[] = { - EBUSY, - EINVAL, 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), }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_rwlockattr_destroy, true); will_return(__wrap_pthread_rwlockattr_destroy, errnos[i]); diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_destroy_callback.c index 188571c..4321ed3 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_attributes_destroy_callback.c @@ -13,18 +13,14 @@ void test__f_thread_lock_attributes_destroy_callback__fails(void **state) { f_thread_lock_attributes_t datass_array[] = { datas }; int errnos[] = { - EBUSY, - EINVAL, 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), }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_rwlockattr_destroy, true); will_return(__wrap_pthread_rwlockattr_destroy, errnos[i]); 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 new file mode 100644 index 0000000..6fd6a76 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c @@ -0,0 +1,72 @@ +#include "test-thread.h" +#include "test-thread-lock_full_delete.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_lock_full_delete__fails(void **state) { + + f_thread_lock_full_t full = f_thread_lock_full_t_initialize; + + int errnos[] = { + EBUSY, + EINVAL, + mock_errno_generic, + }; + + f_status_t statuss[] = { + F_busy, + F_parameter, + F_failure, + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_rwlock_destroy, true); + will_return(__wrap_pthread_rwlock_destroy, errnos[i]); + + const f_status_t status = f_thread_lock_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_rwlock_destroy, false); + will_return(__wrap_pthread_rwlockattr_destroy, true); + will_return(__wrap_pthread_rwlockattr_destroy, errnos[i]); + + const f_status_t status = f_thread_lock_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } // for +} + +void test__f_thread_lock_full_delete__parameter_checking(void **state) { + + { + const f_status_t status = f_thread_lock_full_delete(0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_thread_lock_full_delete__works(void **state) { + + f_thread_lock_full_t full = f_thread_lock_full_t_initialize; + + { + will_return(__wrap_pthread_rwlock_destroy, false); + will_return(__wrap_pthread_rwlockattr_destroy, false); + + const f_status_t status = f_thread_lock_full_delete(&full); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.h b/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.h new file mode 100644 index 0000000..09da984 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the thread project. + */ +#ifndef _TEST__F_thread__lock_full_delete_h +#define _TEST__F_thread__lock_full_delete_h + +/** + * Test that function fails. + * + * @see f_thread_lock_full_delete() + */ +extern void test__f_thread_lock_full_delete__fails(void **state); + +/** + * Test that parameter checking works as expected. + * + * @see f_thread_lock_full_delete() + */ +extern void test__f_thread_lock_full_delete__parameter_checking(void **state); + +/** + * Test that function works. + * + * @see f_thread_lock_full_delete() + */ +extern void test__f_thread_lock_full_delete__works(void **state); + +#endif // _TEST__F_thread__lock_full_delete_h 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 new file mode 100644 index 0000000..884b601 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-lock_fulls_delete_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_lock_fulls_delete_callback__fails(void **state) { + + f_thread_lock_full_t data = f_thread_lock_full_t_initialize; + f_thread_lock_full_t data_array[] = { data }; + f_thread_lock_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_lock_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + 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), + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_rwlock_destroy, true); + will_return(__wrap_pthread_rwlock_destroy, errnos[i]); + + const f_status_t status = f_thread_lock_fulls_delete_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_rwlock_destroy, false); + will_return(__wrap_pthread_rwlockattr_destroy, true); + will_return(__wrap_pthread_rwlockattr_destroy, errnos[i]); + + const f_status_t status = f_thread_lock_fulls_delete_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } +} + +void test__f_thread_lock_fulls_delete_callback__works(void **state) { + + f_thread_lock_full_t data = f_thread_lock_full_t_initialize; + f_thread_lock_full_t data_array[] = { data }; + f_thread_lock_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_lock_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_rwlock_destroy, false); + will_return(__wrap_pthread_rwlockattr_destroy, false); + + const f_status_t status = f_thread_lock_fulls_delete_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.h b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.h new file mode 100644 index 0000000..85e5968 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__lock_fulls_delete_callback +#define _TEST__F_thread__lock_fulls_delete_callback + +/** + * Test that the function fails. + * + * @see f_thread_lock_fulls_delete_callback_() + */ +extern void test__f_thread_lock_fulls_delete_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_lock_fulls_delete_callback_() + */ +extern void test__f_thread_lock_fulls_delete_callback__works(void **state); + +#endif // _TEST__F_thread__lock_fulls_delete_callback 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 new file mode 100644 index 0000000..4ce2837 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-lock_fulls_destroy_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_lock_fulls_destroy_callback__fails(void **state) { + + f_thread_lock_full_t data = f_thread_lock_full_t_initialize; + f_thread_lock_full_t data_array[] = { data }; + f_thread_lock_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_lock_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + 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), + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_rwlock_destroy, true); + will_return(__wrap_pthread_rwlock_destroy, errnos[i]); + + const f_status_t status = f_thread_lock_fulls_destroy_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_rwlock_destroy, false); + will_return(__wrap_pthread_rwlockattr_destroy, true); + will_return(__wrap_pthread_rwlockattr_destroy, errnos[i]); + + const f_status_t status = f_thread_lock_fulls_destroy_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } +} + +void test__f_thread_lock_fulls_destroy_callback__works(void **state) { + + f_thread_lock_full_t data = f_thread_lock_full_t_initialize; + f_thread_lock_full_t data_array[] = { data }; + f_thread_lock_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_lock_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_rwlock_destroy, false); + will_return(__wrap_pthread_rwlockattr_destroy, false); + + const f_status_t status = f_thread_lock_fulls_destroy_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.h b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.h new file mode 100644 index 0000000..7c03de5 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__lock_fulls_destroy_callback +#define _TEST__F_thread__lock_fulls_destroy_callback + +/** + * Test that the function fails. + * + * @see f_thread_lock_fulls_destroy_callback_() + */ +extern void test__f_thread_lock_fulls_destroy_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_lock_fulls_destroy_callback_() + */ +extern void test__f_thread_lock_fulls_destroy_callback__works(void **state); + +#endif // _TEST__F_thread__lock_fulls_destroy_callback diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_attribute_delete.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_attribute_delete.c index c28ef7c..8841a8e 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_attribute_delete.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_attribute_delete.c @@ -10,18 +10,14 @@ void test__f_thread_mutex_attribute_delete__fails(void **state) { f_thread_mutex_attribute_t attribute = f_thread_mutex_attribute_t_initialize; int errnos[] = { - EBUSY, - EINVAL, mock_errno_generic, }; f_status_t statuss[] = { - F_busy, - F_parameter, F_failure, }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_mutexattr_destroy, true); will_return(__wrap_pthread_mutexattr_destroy, errnos[i]); diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_delete_callback.c index 856d198..8f56b58 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_delete_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_delete_callback.c @@ -13,18 +13,14 @@ void test__f_thread_mutex_attributes_delete_callback__fails(void **state) { f_thread_mutex_attributes_t datass_array[] = { datas }; int errnos[] = { - EBUSY, - EINVAL, 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), }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_mutexattr_destroy, true); will_return(__wrap_pthread_mutexattr_destroy, errnos[i]); diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_destroy_callback.c index 35687b3..bbd03b9 100644 --- a/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_destroy_callback.c +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_attributes_destroy_callback.c @@ -13,18 +13,14 @@ void test__f_thread_mutex_attributes_destroy_callback__fails(void **state) { f_thread_mutex_attributes_t datass_array[] = { datas }; int errnos[] = { - EBUSY, - EINVAL, 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), }; - for (uint8_t i = 0; i < 3; ++i) { + for (uint8_t i = 0; i < 1; ++i) { will_return(__wrap_pthread_mutexattr_destroy, true); will_return(__wrap_pthread_mutexattr_destroy, errnos[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 new file mode 100644 index 0000000..411c9b1 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c @@ -0,0 +1,72 @@ +#include "test-thread.h" +#include "test-thread-mutex_full_delete.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_mutex_full_delete__fails(void **state) { + + f_thread_mutex_full_t full = f_thread_mutex_full_t_initialize; + + int errnos[] = { + EBUSY, + EINVAL, + mock_errno_generic, + }; + + f_status_t statuss[] = { + F_busy, + F_parameter, + F_failure, + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_mutex_destroy, true); + will_return(__wrap_pthread_mutex_destroy, errnos[i]); + + const f_status_t status = f_thread_mutex_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_mutex_destroy, false); + will_return(__wrap_pthread_mutexattr_destroy, true); + will_return(__wrap_pthread_mutexattr_destroy, errnos[i]); + + const f_status_t status = f_thread_mutex_full_delete(&full); + + assert_int_equal(status, F_status_set_error(statuss[i])); + } +} + +void test__f_thread_mutex_full_delete__parameter_checking(void **state) { + + { + const f_status_t status = f_thread_mutex_full_delete(0); + + assert_int_equal(status, F_status_set_error(F_parameter)); + } +} + +void test__f_thread_mutex_full_delete__works(void **state) { + + f_thread_mutex_full_t full = f_thread_mutex_full_t_initialize; + + { + will_return(__wrap_pthread_mutex_destroy, false); + will_return(__wrap_pthread_mutexattr_destroy, false); + + const f_status_t status = f_thread_mutex_full_delete(&full); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.h b/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.h new file mode 100644 index 0000000..bf66f3d --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.h @@ -0,0 +1,34 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the thread project. + */ +#ifndef _TEST__F_thread__mutex_full_delete_h +#define _TEST__F_thread__mutex_full_delete_h + +/** + * Test that function fails. + * + * @see f_thread_mutex_full_delete() + */ +extern void test__f_thread_mutex_full_delete__fails(void **state); + +/** + * Test that parameter checking works as expected. + * + * @see f_thread_mutex_full_delete() + */ +extern void test__f_thread_mutex_full_delete__parameter_checking(void **state); + +/** + * Test that function works. + * + * @see f_thread_mutex_full_delete() + */ +extern void test__f_thread_mutex_full_delete__works(void **state); + +#endif // _TEST__F_thread__mutex_full_delete_h 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 new file mode 100644 index 0000000..b657c66 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-mutex_fulls_delete_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_mutex_fulls_delete_callback__fails(void **state) { + + f_thread_mutex_full_t data = f_thread_mutex_full_t_initialize; + f_thread_mutex_full_t data_array[] = { data }; + f_thread_mutex_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_mutex_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + 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), + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_mutex_destroy, true); + will_return(__wrap_pthread_mutex_destroy, errnos[i]); + + const f_status_t status = f_thread_mutex_fulls_delete_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_mutex_destroy, false); + will_return(__wrap_pthread_mutexattr_destroy, true); + will_return(__wrap_pthread_mutexattr_destroy, errnos[i]); + + const f_status_t status = f_thread_mutex_fulls_delete_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } +} + +void test__f_thread_mutex_fulls_delete_callback__works(void **state) { + + f_thread_mutex_full_t data = f_thread_mutex_full_t_initialize; + f_thread_mutex_full_t data_array[] = { data }; + f_thread_mutex_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_mutex_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_mutex_destroy, false); + will_return(__wrap_pthread_mutexattr_destroy, false); + + const f_status_t status = f_thread_mutex_fulls_delete_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.h b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.h new file mode 100644 index 0000000..74bd8f7 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__mutex_fulls_delete_callback +#define _TEST__F_thread__mutex_fulls_delete_callback + +/** + * Test that the function fails. + * + * @see f_thread_mutex_fulls_delete_callback_() + */ +extern void test__f_thread_mutex_fulls_delete_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_mutex_fulls_delete_callback_() + */ +extern void test__f_thread_mutex_fulls_delete_callback__works(void **state); + +#endif // _TEST__F_thread__mutex_fulls_delete_callback 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 new file mode 100644 index 0000000..68e677f --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c @@ -0,0 +1,70 @@ +#include "test-thread.h" +#include "test-thread-mutex_fulls_destroy_callback.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void test__f_thread_mutex_fulls_destroy_callback__fails(void **state) { + + f_thread_mutex_full_t data = f_thread_mutex_full_t_initialize; + f_thread_mutex_full_t data_array[] = { data }; + f_thread_mutex_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_mutex_fulls_t datass_array[] = { datas }; + + int errnos[] = { + EBUSY, + EINVAL, + 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), + }; + + for (uint8_t i = 0; i < 3; ++i) { + + will_return(__wrap_pthread_mutex_destroy, true); + will_return(__wrap_pthread_mutex_destroy, errnos[i]); + + const f_status_t status = f_thread_mutex_fulls_destroy_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } // for + + { + const uint8_t i = 2; + + will_return(__wrap_pthread_mutex_destroy, false); + will_return(__wrap_pthread_mutexattr_destroy, true); + will_return(__wrap_pthread_mutexattr_destroy, errnos[i]); + + const f_status_t status = f_thread_mutex_fulls_destroy_callback(0, 1, (void *) datass_array); + + assert_int_equal(status, statuss[i]); + } +} + +void test__f_thread_mutex_fulls_destroy_callback__works(void **state) { + + f_thread_mutex_full_t data = f_thread_mutex_full_t_initialize; + f_thread_mutex_full_t data_array[] = { data }; + f_thread_mutex_fulls_t datas = { .array = data_array, .used = 1, .size = 1 }; + f_thread_mutex_fulls_t datass_array[] = { datas }; + const f_number_unsigned_t length = 1; + + { + will_return(__wrap_pthread_mutex_destroy, false); + will_return(__wrap_pthread_mutexattr_destroy, false); + + const f_status_t status = f_thread_mutex_fulls_destroy_callback(0, length, (void *) datass_array); + + assert_int_equal(status, F_okay); + } +} + +#ifdef __cplusplus +} // extern "C" +#endif diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.h b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.h new file mode 100644 index 0000000..19c72c5 --- /dev/null +++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.h @@ -0,0 +1,27 @@ +/** + * FLL - Level 0 + * + * Project: Thread + * API Version: 0.7 + * Licenses: lgpl-2.1-or-later + * + * Test the array types in the type project. + */ +#ifndef _TEST__F_thread__mutex_fulls_destroy_callback +#define _TEST__F_thread__mutex_fulls_destroy_callback + +/** + * Test that the function fails. + * + * @see f_thread_mutex_fulls_destroy_callback_() + */ +extern void test__f_thread_mutex_fulls_destroy_callback__fails(void **state); + +/** + * Test that the function works. + * + * @see f_thread_mutex_fulls_destroy_callback_() + */ +extern void test__f_thread_mutex_fulls_destroy_callback__works(void **state); + +#endif // _TEST__F_thread__mutex_fulls_destroy_callback diff --git a/level_0/f_thread/tests/unit/c/test-thread.c b/level_0/f_thread/tests/unit/c/test-thread.c index 61208d5..cdc8848 100644 --- a/level_0/f_thread/tests/unit/c/test-thread.c +++ b/level_0/f_thread/tests/unit/c/test-thread.c @@ -19,70 +19,90 @@ int setdown(void **state) { int main(void) { const struct CMUnitTest tests[] = { - cmocka_unit_test(test__f_thread_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_attributes_delete_callback__fails), - cmocka_unit_test(test__f_thread_attributes_destroy_callback__works), + cmocka_unit_test(test__f_thread_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_attributes_delete_callback__works), + cmocka_unit_test(test__f_thread_attributes_destroy_callback__works), - cmocka_unit_test(test__f_thread_barriers_destroy_callback__fails), cmocka_unit_test(test__f_thread_barriers_delete_callback__fails), - cmocka_unit_test(test__f_thread_barriers_destroy_callback__works), + cmocka_unit_test(test__f_thread_barriers_destroy_callback__fails), cmocka_unit_test(test__f_thread_barriers_delete_callback__works), + cmocka_unit_test(test__f_thread_barriers_destroy_callback__works), - cmocka_unit_test(test__f_thread_barrier_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_barrier_attributes_delete_callback__fails), - cmocka_unit_test(test__f_thread_barrier_attributes_destroy_callback__works), + cmocka_unit_test(test__f_thread_barrier_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_barrier_attributes_delete_callback__works), + cmocka_unit_test(test__f_thread_barrier_attributes_destroy_callback__works), + + cmocka_unit_test(test__f_thread_barrier_fulls_delete_callback__fails), + cmocka_unit_test(test__f_thread_barrier_fulls_destroy_callback__fails), + cmocka_unit_test(test__f_thread_barrier_fulls_delete_callback__works), + cmocka_unit_test(test__f_thread_barrier_fulls_destroy_callback__works), - cmocka_unit_test(test__f_thread_conditions_destroy_callback__fails), cmocka_unit_test(test__f_thread_conditions_delete_callback__fails), - cmocka_unit_test(test__f_thread_conditions_destroy_callback__works), + cmocka_unit_test(test__f_thread_conditions_destroy_callback__fails), cmocka_unit_test(test__f_thread_conditions_delete_callback__works), + cmocka_unit_test(test__f_thread_conditions_destroy_callback__works), - cmocka_unit_test(test__f_thread_condition_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_condition_attributes_delete_callback__fails), - cmocka_unit_test(test__f_thread_condition_attributes_destroy_callback__works), + cmocka_unit_test(test__f_thread_condition_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_condition_attributes_delete_callback__works), + cmocka_unit_test(test__f_thread_condition_attributes_destroy_callback__works), + + cmocka_unit_test(test__f_thread_condition_fulls_delete_callback__fails), + cmocka_unit_test(test__f_thread_condition_fulls_destroy_callback__fails), + cmocka_unit_test(test__f_thread_condition_fulls_delete_callback__works), + cmocka_unit_test(test__f_thread_condition_fulls_destroy_callback__works), - cmocka_unit_test(test__f_thread_keys_destroy_callback__fails), cmocka_unit_test(test__f_thread_keys_delete_callback__fails), - cmocka_unit_test(test__f_thread_keys_destroy_callback__works), + cmocka_unit_test(test__f_thread_keys_destroy_callback__fails), cmocka_unit_test(test__f_thread_keys_delete_callback__works), + cmocka_unit_test(test__f_thread_keys_destroy_callback__works), - cmocka_unit_test(test__f_thread_locks_destroy_callback__fails), cmocka_unit_test(test__f_thread_locks_delete_callback__fails), - cmocka_unit_test(test__f_thread_locks_destroy_callback__works), + cmocka_unit_test(test__f_thread_locks_destroy_callback__fails), cmocka_unit_test(test__f_thread_locks_delete_callback__works), + cmocka_unit_test(test__f_thread_locks_destroy_callback__works), - cmocka_unit_test(test__f_thread_lock_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_lock_attributes_delete_callback__fails), - cmocka_unit_test(test__f_thread_lock_attributes_destroy_callback__works), + cmocka_unit_test(test__f_thread_lock_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_lock_attributes_delete_callback__works), + cmocka_unit_test(test__f_thread_lock_attributes_destroy_callback__works), + + cmocka_unit_test(test__f_thread_lock_fulls_delete_callback__fails), + cmocka_unit_test(test__f_thread_lock_fulls_destroy_callback__fails), + cmocka_unit_test(test__f_thread_lock_fulls_delete_callback__works), + cmocka_unit_test(test__f_thread_lock_fulls_destroy_callback__works), - cmocka_unit_test(test__f_thread_mutexs_destroy_callback__fails), cmocka_unit_test(test__f_thread_mutexs_delete_callback__fails), - cmocka_unit_test(test__f_thread_mutexs_destroy_callback__works), + cmocka_unit_test(test__f_thread_mutexs_destroy_callback__fails), cmocka_unit_test(test__f_thread_mutexs_delete_callback__works), + cmocka_unit_test(test__f_thread_mutexs_destroy_callback__works), - cmocka_unit_test(test__f_thread_mutex_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_mutex_attributes_delete_callback__fails), - cmocka_unit_test(test__f_thread_mutex_attributes_destroy_callback__works), + cmocka_unit_test(test__f_thread_mutex_attributes_destroy_callback__fails), cmocka_unit_test(test__f_thread_mutex_attributes_delete_callback__works), + cmocka_unit_test(test__f_thread_mutex_attributes_destroy_callback__works), + + cmocka_unit_test(test__f_thread_mutex_fulls_delete_callback__fails), + cmocka_unit_test(test__f_thread_mutex_fulls_destroy_callback__fails), + cmocka_unit_test(test__f_thread_mutex_fulls_delete_callback__works), + cmocka_unit_test(test__f_thread_mutex_fulls_destroy_callback__works), - cmocka_unit_test(test__f_thread_semaphores_destroy_callback__fails), cmocka_unit_test(test__f_thread_semaphores_delete_callback__fails), - cmocka_unit_test(test__f_thread_semaphores_destroy_callback__works), + cmocka_unit_test(test__f_thread_semaphores_destroy_callback__fails), cmocka_unit_test(test__f_thread_semaphores_delete_callback__works), + cmocka_unit_test(test__f_thread_semaphores_destroy_callback__works), - cmocka_unit_test(test__f_thread_sets_destroy_callback__fails), cmocka_unit_test(test__f_thread_sets_delete_callback__fails), - cmocka_unit_test(test__f_thread_sets_destroy_callback__works), + cmocka_unit_test(test__f_thread_sets_destroy_callback__fails), cmocka_unit_test(test__f_thread_sets_delete_callback__works), + cmocka_unit_test(test__f_thread_sets_destroy_callback__works), - cmocka_unit_test(test__f_thread_spins_destroy_callback__fails), cmocka_unit_test(test__f_thread_spins_delete_callback__fails), - cmocka_unit_test(test__f_thread_spins_destroy_callback__works), + cmocka_unit_test(test__f_thread_spins_destroy_callback__fails), cmocka_unit_test(test__f_thread_spins_delete_callback__works), + cmocka_unit_test(test__f_thread_spins_destroy_callback__works), cmocka_unit_test(test__f_thread_at_fork__fails), cmocka_unit_test(test__f_thread_at_fork__works), @@ -176,6 +196,9 @@ int main(void) { cmocka_unit_test(test__f_thread_barrier_delete__fails), cmocka_unit_test(test__f_thread_barrier_delete__works), + cmocka_unit_test(test__f_thread_barrier_full_delete__fails), + cmocka_unit_test(test__f_thread_barrier_full_delete__works), + cmocka_unit_test(test__f_thread_barrier_wait__works), cmocka_unit_test(test__f_thread_caller__works), @@ -220,6 +243,9 @@ int main(void) { cmocka_unit_test(test__f_thread_condition_delete__fails), cmocka_unit_test(test__f_thread_condition_delete__works), + cmocka_unit_test(test__f_thread_condition_full_delete__fails), + cmocka_unit_test(test__f_thread_condition_full_delete__works), + cmocka_unit_test(test__f_thread_condition_wait__fails), cmocka_unit_test(test__f_thread_condition_wait__works), @@ -257,6 +283,7 @@ int main(void) { cmocka_unit_test(test__f_thread_lock_attribute_create__fails), cmocka_unit_test(test__f_thread_lock_attribute_create__works), + cmocka_unit_test(test__f_thread_lock_attribute_delete__fails), cmocka_unit_test(test__f_thread_lock_attribute_delete__works), cmocka_unit_test(test__f_thread_lock_attribute_shared_get__fails), @@ -271,6 +298,9 @@ int main(void) { cmocka_unit_test(test__f_thread_lock_delete__fails), cmocka_unit_test(test__f_thread_lock_delete__works), + cmocka_unit_test(test__f_thread_lock_full_delete__fails), + cmocka_unit_test(test__f_thread_lock_full_delete__works), + cmocka_unit_test(test__f_thread_lock_read__fails), cmocka_unit_test(test__f_thread_lock_read__works), @@ -334,6 +364,9 @@ int main(void) { cmocka_unit_test(test__f_thread_mutex_delete__fails), cmocka_unit_test(test__f_thread_mutex_delete__works), + cmocka_unit_test(test__f_thread_mutex_full_delete__fails), + cmocka_unit_test(test__f_thread_mutex_full_delete__works), + cmocka_unit_test(test__f_thread_mutex_lock__fails), cmocka_unit_test(test__f_thread_mutex_lock__works), @@ -422,44 +455,56 @@ int main(void) { cmocka_unit_test(test__f_thread_spin_unlock__works), #ifndef _di_level_0_parameter_checking_ - // f_thread_attributes_destroy_callback() doesn't use parameter checking. // f_thread_attributes_delete_callback() doesn't use parameter checking. + // f_thread_attributes_destroy_callback() doesn't use parameter checking. - // f_thread_barriers_destroy_callback() doesn't use parameter checking. // f_thread_barriers_delete_callback() doesn't use parameter checking. + // f_thread_barriers_destroy_callback() doesn't use parameter checking. - // f_thread_barrier_attributes_destroy_callback() doesn't use parameter checking. // f_thread_barrier_attributes_delete_callback() doesn't use parameter checking. + // f_thread_barrier_attributes_destroy_callback() doesn't use parameter checking. + + // f_thread_barrier_fulls_delete_callback() doesn't use parameter checking. + // f_thread_barrier_fulls_destroy_callback() doesn't use parameter checking. - // f_thread_conditions_destroy_callback() doesn't use parameter checking. // f_thread_conditions_delete_callback() doesn't use parameter checking. + // f_thread_conditions_destroy_callback() doesn't use parameter checking. - // f_thread_condition_attributes_destroy_callback() doesn't use parameter checking. // f_thread_condition_attributes_delete_callback() doesn't use parameter checking. + // f_thread_condition_attributes_destroy_callback() doesn't use parameter checking. + + // f_thread_condition_fulls_delete_callback() doesn't use parameter checking. + // f_thread_condition_fulls_destroy_callback() doesn't use parameter checking. - // f_thread_keys_destroy_callback() doesn't use parameter checking. // f_thread_keys_delete_callback() doesn't use parameter checking. + // f_thread_keys_destroy_callback() doesn't use parameter checking. - // f_thread_locks_destroy_callback() doesn't use parameter checking. // f_thread_locks_delete_callback() doesn't use parameter checking. + // f_thread_locks_destroy_callback() doesn't use parameter checking. - // f_thread_lock_attributes_destroy_callback() doesn't use parameter checking. // f_thread_lock_attributes_delete_callback() doesn't use parameter checking. + // f_thread_lock_attributes_destroy_callback() doesn't use parameter checking. + + // f_thread_lock_fulls_delete_callback() doesn't use parameter checking. + // f_thread_lock_fulls_destroy_callback() doesn't use parameter checking. - // f_thread_mutexs_destroy_callback() doesn't use parameter checking. // f_thread_mutexs_delete_callback() doesn't use parameter checking. + // f_thread_mutexs_destroy_callback() doesn't use parameter checking. - // f_thread_mutex_attributes_destroy_callback() doesn't use parameter checking. // f_thread_mutex_attributes_delete_callback() doesn't use parameter checking. + // f_thread_mutex_attributes_destroy_callback() doesn't use parameter checking. + + // f_thread_mutex_fulls_delete_callback() doesn't use parameter checking. + // f_thread_mutex_fulls_destroy_callback() doesn't use parameter checking. - // f_thread_semaphores_destroy_callback() doesn't use parameter checking. // f_thread_semaphores_delete_callback() doesn't use parameter checking. + // f_thread_semaphores_destroy_callback() doesn't use parameter checking. - // f_thread_sets_destroy_callback() doesn't use parameter checking. // f_thread_sets_delete_callback() doesn't use parameter checking. + // f_thread_sets_destroy_callback() doesn't use parameter checking. - // f_thread_spins_destroy_callback() doesn't use parameter checking. // f_thread_spins_delete_callback() doesn't use parameter checking. + // f_thread_spins_destroy_callback() doesn't use parameter checking. cmocka_unit_test(test__f_thread_at_fork__parameter_checking), @@ -512,6 +557,8 @@ int main(void) { cmocka_unit_test(test__f_thread_barrier_delete__parameter_checking), + cmocka_unit_test(test__f_thread_barrier_full_delete__parameter_checking), + cmocka_unit_test(test__f_thread_barrier_wait__parameter_checking), // f_thread_caller() doesn't use parameter checking. @@ -540,6 +587,8 @@ int main(void) { cmocka_unit_test(test__f_thread_condition_create__parameter_checking), + cmocka_unit_test(test__f_thread_condition_full_delete__parameter_checking), + cmocka_unit_test(test__f_thread_condition_signal__parameter_checking), cmocka_unit_test(test__f_thread_condition_signal_all__parameter_checking), @@ -580,6 +629,8 @@ int main(void) { cmocka_unit_test(test__f_thread_lock_delete__parameter_checking), + cmocka_unit_test(test__f_thread_lock_full_delete__parameter_checking), + cmocka_unit_test(test__f_thread_lock_read__parameter_checking), cmocka_unit_test(test__f_thread_lock_read_timed__parameter_checking), @@ -620,6 +671,8 @@ int main(void) { cmocka_unit_test(test__f_thread_mutex_delete__parameter_checking), + cmocka_unit_test(test__f_thread_mutex_full_delete__parameter_checking), + cmocka_unit_test(test__f_thread_mutex_lock__parameter_checking), cmocka_unit_test(test__f_thread_mutex_lock_timed__parameter_checking), diff --git a/level_0/f_thread/tests/unit/c/test-thread.h b/level_0/f_thread/tests/unit/c/test-thread.h index c7d574f..05dfd6f 100644 --- a/level_0/f_thread/tests/unit/c/test-thread.h +++ b/level_0/f_thread/tests/unit/c/test-thread.h @@ -27,33 +27,6 @@ #include "mock-thread.h" // Test includes. -#include "test-thread-attributes_destroy_callback.h" -#include "test-thread-attributes_delete_callback.h" -#include "test-thread-barriers_destroy_callback.h" -#include "test-thread-barriers_delete_callback.h" -#include "test-thread-barrier_attributes_destroy_callback.h" -#include "test-thread-barrier_attributes_delete_callback.h" -#include "test-thread-conditions_destroy_callback.h" -#include "test-thread-conditions_delete_callback.h" -#include "test-thread-condition_attributes_destroy_callback.h" -#include "test-thread-condition_attributes_delete_callback.h" -#include "test-thread-keys_destroy_callback.h" -#include "test-thread-keys_delete_callback.h" -#include "test-thread-locks_destroy_callback.h" -#include "test-thread-locks_delete_callback.h" -#include "test-thread-lock_attributes_destroy_callback.h" -#include "test-thread-lock_attributes_delete_callback.h" -#include "test-thread-mutexs_destroy_callback.h" -#include "test-thread-mutexs_delete_callback.h" -#include "test-thread-mutex_attributes_destroy_callback.h" -#include "test-thread-mutex_attributes_delete_callback.h" -#include "test-thread-semaphores_destroy_callback.h" -#include "test-thread-semaphores_delete_callback.h" -#include "test-thread-sets_destroy_callback.h" -#include "test-thread-sets_delete_callback.h" -#include "test-thread-spins_destroy_callback.h" -#include "test-thread-spins_delete_callback.h" - #include "test-thread-at_fork.h" #include "test-thread-attribute_affinity_get.h" #include "test-thread-attribute_affinity_set.h" @@ -79,13 +52,22 @@ #include "test-thread-attribute_stack_set.h" #include "test-thread-attribute_stack_size_get.h" #include "test-thread-attribute_stack_size_set.h" +#include "test-thread-attributes_delete_callback.h" +#include "test-thread-attributes_destroy_callback.h" #include "test-thread-barrier_attribute_create.h" #include "test-thread-barrier_attribute_delete.h" #include "test-thread-barrier_attribute_shared_get.h" #include "test-thread-barrier_attribute_shared_set.h" +#include "test-thread-barrier_attributes_delete_callback.h" +#include "test-thread-barrier_attributes_destroy_callback.h" #include "test-thread-barrier_create.h" #include "test-thread-barrier_delete.h" +#include "test-thread-barrier_full_delete.h" +#include "test-thread-barrier_fulls_delete_callback.h" +#include "test-thread-barrier_fulls_destroy_callback.h" #include "test-thread-barrier_wait.h" +#include "test-thread-barriers_delete_callback.h" +#include "test-thread-barriers_destroy_callback.h" #include "test-thread-caller.h" #include "test-thread-cancel.h" #include "test-thread-cancel_state_set.h" @@ -99,12 +81,19 @@ #include "test-thread-condition_attribute_delete.h" #include "test-thread-condition_attribute_shared_get.h" #include "test-thread-condition_attribute_shared_set.h" +#include "test-thread-condition_attributes_delete_callback.h" +#include "test-thread-condition_attributes_destroy_callback.h" #include "test-thread-condition_create.h" #include "test-thread-condition_delete.h" +#include "test-thread-condition_full_delete.h" +#include "test-thread-condition_fulls_delete_callback.h" +#include "test-thread-condition_fulls_destroy_callback.h" #include "test-thread-condition_signal.h" #include "test-thread-condition_signal_all.h" #include "test-thread-condition_wait.h" #include "test-thread-condition_wait_timed.h" +#include "test-thread-conditions_delete_callback.h" +#include "test-thread-conditions_destroy_callback.h" #include "test-thread-create.h" #include "test-thread-detach.h" #include "test-thread-exit.h" @@ -115,18 +104,27 @@ #include "test-thread-key_delete.h" #include "test-thread-key_get.h" #include "test-thread-key_set.h" +#include "test-thread-keys_delete_callback.h" +#include "test-thread-keys_destroy_callback.h" #include "test-thread-lock_attribute_create.h" #include "test-thread-lock_attribute_delete.h" #include "test-thread-lock_attribute_shared_get.h" #include "test-thread-lock_attribute_shared_set.h" +#include "test-thread-lock_attributes_delete_callback.h" +#include "test-thread-lock_attributes_destroy_callback.h" #include "test-thread-lock_create.h" #include "test-thread-lock_delete.h" +#include "test-thread-lock_full_delete.h" +#include "test-thread-lock_fulls_delete_callback.h" +#include "test-thread-lock_fulls_destroy_callback.h" #include "test-thread-lock_read.h" #include "test-thread-lock_read_timed.h" #include "test-thread-lock_read_try.h" #include "test-thread-lock_write.h" #include "test-thread-lock_write_timed.h" #include "test-thread-lock_write_try.h" +#include "test-thread-locks_delete_callback.h" +#include "test-thread-locks_destroy_callback.h" #include "test-thread-mutex_attribute_create.h" #include "test-thread-mutex_attribute_delete.h" #include "test-thread-mutex_attribute_priority_ceiling_get.h" @@ -139,14 +137,21 @@ #include "test-thread-mutex_attribute_type_set.h" #include "test-thread-mutex_attribute_protocol_get.h" #include "test-thread-mutex_attribute_protocol_set.h" +#include "test-thread-mutex_attributes_delete_callback.h" +#include "test-thread-mutex_attributes_destroy_callback.h" #include "test-thread-mutex_consistent.h" #include "test-thread-mutex_create.h" #include "test-thread-mutex_delete.h" +#include "test-thread-mutex_full_delete.h" +#include "test-thread-mutex_fulls_delete_callback.h" +#include "test-thread-mutex_fulls_destroy_callback.h" #include "test-thread-mutex_lock.h" #include "test-thread-mutex_lock_timed.h" #include "test-thread-mutex_lock_try.h" #include "test-thread-mutex_priority_ceiling_get.h" #include "test-thread-mutex_priority_ceiling_set.h" +#include "test-thread-mutexs_delete_callback.h" +#include "test-thread-mutexs_destroy_callback.h" #include "test-thread-name_get.h" #include "test-thread-name_set.h" #include "test-thread-once.h" @@ -163,6 +168,10 @@ #include "test-thread-semaphore_lock_try.h" #include "test-thread-semaphore_unlock.h" #include "test-thread-semaphore_value_get.h" +#include "test-thread-semaphores_delete_callback.h" +#include "test-thread-semaphores_destroy_callback.h" +#include "test-thread-sets_delete_callback.h" +#include "test-thread-sets_destroy_callback.h" #include "test-thread-signal_mask.h" #include "test-thread-signal_queue.h" #include "test-thread-signal_write.h" @@ -171,6 +180,8 @@ #include "test-thread-spin_lock.h" #include "test-thread-spin_lock_try.h" #include "test-thread-spin_unlock.h" +#include "test-thread-spins_delete_callback.h" +#include "test-thread-spins_destroy_callback.h" #ifdef __cplusplus extern "C" { -- 1.8.3.1