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.
}
#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_
#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_
}
#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_
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_
#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);
}
#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_
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_
}
#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_
#include <fll/level_0/thread/attribute.h>
#include <fll/level_0/thread/barrier.h>
#include <fll/level_0/thread/barrier_attribute.h>
+#include <fll/level_0/thread/barrier_full.h>
#include <fll/level_0/thread/condition.h>
#include <fll/level_0/thread/condition_attribute.h>
+#include <fll/level_0/thread/condition_full.h>
#include <fll/level_0/thread/id.h>
#include <fll/level_0/thread/key.h>
#include <fll/level_0/thread/lock.h>
#include <fll/level_0/thread/lock_attribute.h>
+#include <fll/level_0/thread/lock_full.h>
#include <fll/level_0/thread/mutex.h>
#include <fll/level_0/thread/mutex_attribute.h>
+#include <fll/level_0/thread/mutex_full.h>
#include <fll/level_0/thread/once.h>
#include <fll/level_0/thread/semaphore.h>
#include <fll/level_0/thread/set.h>
* @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.
#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
#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.
* @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.
*
* 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()
#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.
/**
* 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
* @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.
/**
* 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
#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.
* 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()
* @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()
* 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()
* 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()
#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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
* @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);
* @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);
* @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);
* @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);
#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;
}
#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;
}
#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;
}
#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;
}
#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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
#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;
}
#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;
}
#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;
}
#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;
}
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
#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;
}
#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;
}
#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;
}
#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;
}
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
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
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
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
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
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
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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
};
for (uint8_t i = 0; i < 3; ++i) {
+
will_return(__wrap_pthread_barrier_destroy, true);
will_return(__wrap_pthread_barrier_destroy, errnos[i]);
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]);
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]);
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]);
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
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]);
#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()
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]);
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]);
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
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]);
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]);
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]);
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
--- /dev/null
+#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
--- /dev/null
+/**
+ * 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
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),
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),
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),
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),
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),
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),
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),
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.
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),
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),
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),
#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"
#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"
#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"
#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"
#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"
#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"
#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" {
projects / fll / commitdiff