#define _di_f_thread_mutex_attribute_priority_ceiling_set_
#define _di_f_thread_mutex_attribute_protocol_get_
#define _di_f_thread_mutex_attribute_protocol_set_
+#define _di_f_thread_mutex_attribute_robust_get_
+#define _di_f_thread_mutex_attribute_robust_set_
#define _di_f_thread_mutex_attribute_shared_get_
#define _di_f_thread_mutex_attribute_shared_set_
#define _di_f_thread_mutex_attribute_d_
#define _di_f_thread_mutex_attributes_t_
#define _di_f_thread_mutex_attributess_delete_callback_
#define _di_f_thread_mutex_attributess_destroy_callback_
+#define _di_f_thread_mutex_consistent_
#define _di_f_thread_mutex_create_
+#define _di_f_thread_mutex_d_
#define _di_f_thread_mutex_delete_
#define _di_f_thread_mutex_lock_
#define _di_f_thread_mutex_lock_timed_
#define _di_f_thread_mutex_attribute_priority_ceiling_set_
#define _di_f_thread_mutex_attribute_protocol_get_
#define _di_f_thread_mutex_attribute_protocol_set_
+#define _di_f_thread_mutex_attribute_robust_get_
+#define _di_f_thread_mutex_attribute_robust_set_
#define _di_f_thread_mutex_attribute_shared_get_
#define _di_f_thread_mutex_attribute_shared_set_
#define _di_f_thread_mutex_attribute_d_
#define _di_f_thread_mutex_attributes_t_
#define _di_f_thread_mutex_attributess_delete_callback_
#define _di_f_thread_mutex_attributess_destroy_callback_
+#define _di_f_thread_mutex_consistent_
#define _di_f_thread_mutex_create_
+#define _di_f_thread_mutex_d_
#define _di_f_thread_mutex_delete_
#define _di_f_thread_mutex_lock_
#define _di_f_thread_mutex_lock_timed_
#define _di_f_thread_mutex_attribute_priority_ceiling_set_
#define _di_f_thread_mutex_attribute_protocol_get_
#define _di_f_thread_mutex_attribute_protocol_set_
+#define _di_f_thread_mutex_attribute_robust_get_
+#define _di_f_thread_mutex_attribute_robust_set_
#define _di_f_thread_mutex_attribute_shared_get_
#define _di_f_thread_mutex_attribute_shared_set_
#define _di_f_thread_mutex_attribute_d_
#define _di_f_thread_mutex_attributes_t_
#define _di_f_thread_mutex_attributess_delete_callback_
#define _di_f_thread_mutex_attributess_destroy_callback_
+#define _di_f_thread_mutex_consistent_
#define _di_f_thread_mutex_create_
+#define _di_f_thread_mutex_d_
#define _di_f_thread_mutex_delete_
#define _di_f_thread_mutex_lock_
#define _di_f_thread_mutex_lock_timed_
#define _di_f_thread_mutex_attribute_priority_ceiling_set_
#define _di_f_thread_mutex_attribute_protocol_get_
#define _di_f_thread_mutex_attribute_protocol_set_
+#define _di_f_thread_mutex_attribute_robust_get_
+#define _di_f_thread_mutex_attribute_robust_set_
#define _di_f_thread_mutex_attribute_shared_get_
#define _di_f_thread_mutex_attribute_shared_set_
#define _di_f_thread_mutex_attribute_d_
#define _di_f_thread_mutex_attributes_t_
#define _di_f_thread_mutex_attributess_delete_callback_
#define _di_f_thread_mutex_attributess_destroy_callback_
+#define _di_f_thread_mutex_consistent_
#define _di_f_thread_mutex_create_
+#define _di_f_thread_mutex_d_
#define _di_f_thread_mutex_delete_
#define _di_f_thread_mutex_lock_
#define _di_f_thread_mutex_lock_timed_
#define _di_f_thread_mutex_attribute_priority_ceiling_set_
#define _di_f_thread_mutex_attribute_protocol_get_
#define _di_f_thread_mutex_attribute_protocol_set_
+#define _di_f_thread_mutex_attribute_robust_get_
+#define _di_f_thread_mutex_attribute_robust_set_
#define _di_f_thread_mutex_attribute_shared_get_
#define _di_f_thread_mutex_attribute_shared_set_
#define _di_f_thread_mutex_attribute_d_
#define _di_f_thread_mutex_attributes_t_
#define _di_f_thread_mutex_attributess_delete_callback_
#define _di_f_thread_mutex_attributess_destroy_callback_
+#define _di_f_thread_mutex_consistent_
#define _di_f_thread_mutex_create_
+#define _di_f_thread_mutex_d_
#define _di_f_thread_mutex_delete_
#define _di_f_thread_mutex_lock_
#define _di_f_thread_mutex_lock_timed_
#define _di_f_thread_mutex_attribute_priority_ceiling_set_
#define _di_f_thread_mutex_attribute_protocol_get_
#define _di_f_thread_mutex_attribute_protocol_set_
+#define _di_f_thread_mutex_attribute_robust_get_
+#define _di_f_thread_mutex_attribute_robust_set_
#define _di_f_thread_mutex_attribute_shared_get_
#define _di_f_thread_mutex_attribute_shared_set_
#define _di_f_thread_mutex_attribute_d_
#define _di_f_thread_mutex_attributes_t_
#define _di_f_thread_mutex_attributess_delete_callback_
#define _di_f_thread_mutex_attributess_destroy_callback_
+#define _di_f_thread_mutex_consistent_
#define _di_f_thread_mutex_create_
+#define _di_f_thread_mutex_d_
#define _di_f_thread_mutex_delete_
#define _di_f_thread_mutex_lock_
#define _di_f_thread_mutex_lock_timed_
F_connect_not,
F_connect_refuse,
F_connect_reset,
+ F_consistent,
+ F_consistent_not,
F_container,
F_container_not,
F_content,
F_restore_not,
F_revert,
F_revert_not,
+ F_robust,
+ F_robust_not,
F_schedule,
F_schedule_not,
F_search,
const f_string_static_t f_status_connect_not_s = macro_f_string_static_t_initialize_1(F_status_connect_not_s, 0, F_status_connect_not_s_length);
const f_string_static_t f_status_connect_refuse_s = macro_f_string_static_t_initialize_1(F_status_connect_refuse_s, 0, F_status_connect_refuse_s_length);
const f_string_static_t f_status_connect_reset_s = macro_f_string_static_t_initialize_1(F_status_connect_reset_s, 0, F_status_connect_reset_s_length);
+ const f_string_static_t f_status_consistent_s = macro_f_string_static_t_initialize_1(F_status_consistent_s, 0, F_status_consistent_s_length);
+ const f_string_static_t f_status_consistent_not_s = macro_f_string_static_t_initialize_1(F_status_consistent_not_s, 0, F_status_consistent_not_s_length);
const f_string_static_t f_status_container_s = macro_f_string_static_t_initialize_1(F_status_container_s, 0, F_status_container_s_length);
const f_string_static_t f_status_container_not_s = macro_f_string_static_t_initialize_1(F_status_container_not_s, 0, F_status_container_not_s_length);
const f_string_static_t f_status_content_s = macro_f_string_static_t_initialize_1(F_status_content_s, 0, F_status_content_s_length);
const f_string_static_t f_status_restore_not_s = macro_f_string_static_t_initialize_1(F_status_restore_not_s, 0, F_status_restore_not_s_length);
const f_string_static_t f_status_revert_s = macro_f_string_static_t_initialize_1(F_status_revert_s, 0, F_status_revert_s_length);
const f_string_static_t f_status_revert_not_s = macro_f_string_static_t_initialize_1(F_status_revert_not_s, 0, F_status_revert_not_s_length);
+ const f_string_static_t f_status_robust_s = macro_f_string_static_t_initialize_1(F_status_robust_s, 0, F_status_robust_s_length);
+ const f_string_static_t f_status_robust_not_s = macro_f_string_static_t_initialize_1(F_status_robust_not_s, 0, F_status_robust_not_s_length);
const f_string_static_t f_status_schedule_s = macro_f_string_static_t_initialize_1(F_status_schedule_s, 0, F_status_schedule_s_length);
const f_string_static_t f_status_schedule_not_s = macro_f_string_static_t_initialize_1(F_status_schedule_not_s, 0, F_status_schedule_not_s_length);
const f_string_static_t f_status_search_s = macro_f_string_static_t_initialize_1(F_status_search_s, 0, F_status_search_s_length);
break;
+ case F_consistent:
+ *name = f_status_consistent_s;
+
+ break;
+
+ case F_consistent_not:
+ *name = f_status_consistent_not_s;
+
+ break;
+
+ case F_container:
+ *name = f_status_container_s;
+
+ break;
+
+ case F_container_not:
+ *name = f_status_container_not_s;
+
+ break;
+
case F_content:
*name = f_status_content_s;
break;
- case F_container:
- *name = f_status_container_s;
-
- break;
-
- case F_container_not:
- *name = f_status_container_not_s;
-
- break;
-
case F_control:
*name = f_status_control_s;
break;
+ case F_robust:
+ *name = f_status_robust_s;
+
+ break;
+
+ case F_robust_not:
+ *name = f_status_robust_not_s;
+
+ break;
+
case F_schedule:
*name = f_status_schedule_s;
#define F_status_connect_not_s "F_connect_not"
#define F_status_connect_refuse_s "F_connect_refuse"
#define F_status_connect_reset_s "F_connect_reset"
+ #define F_status_consistent_s "F_consistent"
+ #define F_status_consistent_not_s "F_consistent_not"
#define F_status_container_s "F_container"
#define F_status_container_not_s "F_container_not"
#define F_status_content_s "F_content"
#define F_status_restore_not_s "F_restore_not"
#define F_status_revert_s "F_revert"
#define F_status_revert_not_s "F_revert_not"
+ #define F_status_robust_s "F_robust"
+ #define F_status_robust_not_s "F_robust_not"
#define F_status_schedule_s "F_schedule"
#define F_status_schedule_not_s "F_schedule_not"
#define F_status_search_s "F_search"
#define F_status_connect_not_s_length 13
#define F_status_connect_refuse_s_length 16
#define F_status_connect_reset_s_length 15
+ #define F_status_consistent_s_length 12
+ #define F_status_consistent_not_s_length 16
#define F_status_container_s_length 11
#define F_status_container_not_s_length 15
#define F_status_content_s_length 9
#define F_status_restore_not_s_length 13
#define F_status_revert_s_length 8
#define F_status_revert_not_s_length 12
+ #define F_status_robust_s_length 8
+ #define F_status_robust_not_s_length 12
#define F_status_schedule_s_length 10
#define F_status_schedule_not_s_length 14
#define F_status_search_s_length 8
extern const f_string_static_t f_status_connect_not_s;
extern const f_string_static_t f_status_connect_refuse_s;
extern const f_string_static_t f_status_connect_reset_s;
+ extern const f_string_static_t f_status_consistent_s;
+ extern const f_string_static_t f_status_consistent_not_s;
extern const f_string_static_t f_status_container_s;
extern const f_string_static_t f_status_container_not_s;
extern const f_string_static_t f_status_content_s;
extern const f_string_static_t f_status_restore_not_s;
extern const f_string_static_t f_status_revert_s;
extern const f_string_static_t f_status_revert_not_s;
+ extern const f_string_static_t f_status_robust_s;
+ extern const f_string_static_t f_status_robust_not_s;
extern const f_string_static_t f_status_schedule_s;
extern const f_string_static_t f_status_schedule_not_s;
extern const f_string_static_t f_status_search_s;
F_connect_not,
F_connect_refuse,
F_connect_reset,
+ F_consistent,
+ F_consistent_not,
F_container,
F_container_not,
F_content,
F_restore_not,
F_revert,
F_revert_not,
+ F_robust,
+ F_robust_not,
F_schedule,
F_schedule_not,
F_search,
f_status_connect_not_s,
f_status_connect_refuse_s,
f_status_connect_reset_s,
+ f_status_consistent_s,
+ f_status_consistent_not_s,
f_status_container_s,
f_status_container_not_s,
f_status_content_s,
f_status_restore_not_s,
f_status_revert_s,
f_status_revert_not_s,
+ f_status_robust_s,
+ f_status_robust_not_s,
f_status_schedule_s,
f_status_schedule_not_s,
f_status_search_s,
f_status_status_code_last_s,
};
- for (uint16_t i = 0; i < 664; ++i) {
+ for (uint16_t i = 0; i < 668; ++i) {
f_string_static_t result = f_string_static_t_initialize;
}
#endif // _di_f_thread_mutex_attribute_protocol_set_
+#ifndef _di_f_thread_mutex_attribute_robust_get_
+ f_status_t f_thread_mutex_attribute_robust_get(f_thread_mutex_attribute_t * const attribute, int * const robust) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!attribute) return F_status_set_error(F_parameter);
+ if (!robust) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ const int error = pthread_mutexattr_getrobust(attribute, robust);
+
+ if (error) {
+ return F_status_set_error(F_failure);
+ }
+
+ return F_okay;
+ }
+#endif // _di_f_thread_mutex_attribute_robust_get_
+
+#ifndef _di_f_thread_mutex_attribute_robust_set_
+ f_status_t f_thread_mutex_attribute_robust_set(const int robust, f_thread_mutex_attribute_t * const attribute) {
+ #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_setrobust(attribute, robust);
+
+ if (error) {
+ if (error == EINVAL) return F_status_set_error(F_parameter);
+
+ return F_status_set_error(F_failure);
+ }
+
+ return F_okay;
+ }
+#endif // _di_f_thread_mutex_attribute_robust_set_
+
#ifndef _di_f_thread_mutex_attribute_shared_get_
f_status_t f_thread_mutex_attribute_shared_get(const f_thread_mutex_attribute_t * const attribute, int * const shared) {
#ifndef _di_level_0_parameter_checking_
}
#endif // _di_f_thread_mutex_attribute_type_set_
+#ifndef _di_f_thread_mutex_consistent_
+ f_status_t f_thread_mutex_consistent(f_thread_mutex_t * const mutex) {
+ #ifndef _di_level_0_parameter_checking_
+ if (!mutex) return F_status_set_error(F_parameter);
+ #endif // _di_level_0_parameter_checking_
+
+ const int error = pthread_mutex_consistent(mutex);
+
+ if (error) {
+ if (error == EINVAL) return F_status_set_error(F_robust_not);
+
+ return F_status_set_error(F_failure);
+ }
+
+ return F_okay;
+ }
+#endif // _di_f_thread_mutex_consistent_
+
#ifndef _di_f_thread_mutex_create_
f_status_t f_thread_mutex_create(f_thread_mutex_attribute_t * const attribute, f_thread_mutex_t * const mutex) {
#ifndef _di_level_0_parameter_checking_
#endif // _di_f_thread_mutex_attribute_protocol_set_
/**
+ * Get the robust mutex attribute.
+ *
+ * @param attribute
+ * The mutex attributes to set the value of.
+ *
+ * Must not be NULL.
+ * @param robust
+ * The value to set to robust attribute to.
+ * See f_thread_mutex_stalled_d and f_thread_mutex_robust_d.
+ *
+ * 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_mutexattr_setrobust()
+ */
+#ifndef _di_f_thread_mutex_attribute_robust_get_
+ extern f_status_t f_thread_mutex_attribute_robust_get(f_thread_mutex_attribute_t * const attribute, int * const robust);
+#endif // _di_f_thread_mutex_attribute_robust_get_
+
+/**
+ * Set the robust mutex attribute.
+ *
+ * @param robust
+ * The value to set to robust attribute to.
+ * See f_thread_mutex_stalled_d and f_thread_mutex_robust_d.
+ * @param attribute
+ * The mutex attributes to set the value of.
+ *
+ * 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_mutexattr_setrobust()
+ */
+#ifndef _di_f_thread_mutex_attribute_robust_set_
+ extern f_status_t f_thread_mutex_attribute_robust_set(const int robust, f_thread_mutex_attribute_t * const attribute);
+#endif // _di_f_thread_mutex_attribute_robust_set_
+
+/**
* Get the mutex attribute process shared thread attribute.
*
* @param attribute
#endif // _di_f_thread_mutex_attribute_type_set_
/**
+ * Mark a robust mutex as consistent.
+ *
+ * Use this to re-mark a mutex that is no longer in a consistent state.
+ *
+ * This should be used to address mutex locks that return F_dead when attempting to acquire a lock.
+ *
+ * @param mutex
+ * The thread mutex.
+ *
+ * Must not be NULL.
+ *
+ * @return
+ * F_okay on success.
+ *
+ * F_parameter (with error bit) if a parameter is invalid.
+ * F_robust (with error bit) if mutex is either not robust or it does not protect from an inconsistent state.
+ *
+ * F_failure (with error bit) on any other error.
+ *
+ * @see pthread_mutex_consistent()
+ */
+#ifndef _di_f_thread_mutex_consistent_
+ extern f_status_t f_thread_mutex_consistent(f_thread_mutex_t * const mutex);
+#endif // _di_f_thread_mutex_consistent_
+
+/**
* Create a thread mutex.
*
* @param attribute
#endif
/**
+ * Mutex defines.
+ *
+ * f_thread_mutex_*_d:
+ * - robust: The mutex is in a robust state.
+ * - stalled: The mutex is in a stalled state (non-robust), such as when F_dead is returned on lock attempts.
+ */
+#ifndef _di_f_thread_mutex_d_
+ #define f_thread_mutex_robust_d PTHREAD_MUTEX_ROBUST
+ #define f_thread_mutex_stalled_d PTHREAD_MUTEX_STALLED
+#endif // _di_f_thread_mutex_d_
+
+/**
* A typedef representing pthread_mutex_t.
*
* This variable cannot be cleared by setting value to 0, so there is no clear macro provided.
flags -Wl,--wrap=pthread_key_create
flags -Wl,--wrap=pthread_key_delete
flags -Wl,--wrap=pthread_kill
+flags -Wl,--wrap=pthread_mutex_consistent
flags -Wl,--wrap=pthread_mutex_destroy
flags -Wl,--wrap=pthread_mutex_getprioceiling
flags -Wl,--wrap=pthread_mutex_init
flags -Wl,--wrap=pthread_mutexattr_getprioceiling
flags -Wl,--wrap=pthread_mutexattr_getprotocol
flags -Wl,--wrap=pthread_mutexattr_getpshared
+flags -Wl,--wrap=pthread_mutexattr_getrobust
flags -Wl,--wrap=pthread_mutexattr_gettype
flags -Wl,--wrap=pthread_mutexattr_setprioceiling
flags -Wl,--wrap=pthread_mutexattr_setprotocol
flags -Wl,--wrap=pthread_mutexattr_setpshared
+flags -Wl,--wrap=pthread_mutexattr_setrobust
flags -Wl,--wrap=pthread_mutexattr_settype
flags -Wl,--wrap=pthread_once
flags -Wl,--wrap=pthread_rwlock_destroy
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-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_attribute_shared_get.c test-thread-mutex_attribute_shared_set.c
build_sources_program test-thread-mutex_attribute_type_get.c test-thread-mutex_attribute_type_set.c
build_sources_program test-thread-mutex_attribute_protocol_get.c test-thread-mutex_attribute_protocol_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
return 0;
}
+int __wrap_pthread_mutex_consistent(pthread_mutex_t *mutex) {
+
+ const bool failure = mock_type(bool);
+
+ if (failure) {
+ return mock_type(int);
+ }
+
+ return 0;
+}
+
int __wrap_pthread_mutex_destroy(pthread_mutex_t *mutex) {
const bool failure = mock_type(bool);
return 0;
}
+int __wrap_pthread_mutexattr_getrobust(const pthread_mutexattr_t *restrict attr, int *restrict robust) {
+
+ const bool failure = mock_type(bool);
+
+ if (failure) {
+ return mock_type(int);
+ }
+
+ return 0;
+}
+
+int __wrap_pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust) {
+
+ const bool failure = mock_type(bool);
+
+ if (failure) {
+ return mock_type(int);
+ }
+
+ return 0;
+}
+
int __wrap_pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind) {
const bool failure = mock_type(bool);
extern int __wrap_pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
extern int __wrap_pthread_key_delete(pthread_key_t key);
extern int __wrap_pthread_kill(pthread_t thread, int sig);
+extern int __wrap_pthread_mutex_consistent(pthread_mutex_t *mutex);
extern int __wrap_pthread_mutex_destroy(pthread_mutex_t *mutex);
extern int __wrap_pthread_mutex_getprioceiling(const pthread_mutex_t * restrict mutex, int *prioceiling);
extern int __wrap_pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
extern int __wrap_pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr, int *prioceiling);
extern int __wrap_pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol);
extern int __wrap_pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared);
+extern int __wrap_pthread_mutexattr_getrobust(const pthread_mutexattr_t *restrict attr, int *restrict robust);
+extern int __wrap_pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust);
extern int __wrap_pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *kind);
extern int __wrap_pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling);
extern int __wrap_pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol);
--- /dev/null
+#include "test-thread.h"
+#include "test-thread-mutex_attribute_robust_get.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_thread_mutex_attribute_robust_get__fails(void **state) {
+
+ f_thread_mutex_attribute_t attribute = f_thread_mutex_attribute_t_initialize;
+ int robust = 0;
+
+ int errnos[] = {
+ mock_errno_generic,
+ };
+
+ f_status_t statuss[] = {
+ F_failure,
+ };
+
+ for (uint8_t i = 0; i < 1; ++i) {
+
+ will_return(__wrap_pthread_mutexattr_getrobust, true);
+ will_return(__wrap_pthread_mutexattr_getrobust, errnos[i]);
+
+ const f_status_t status = f_thread_mutex_attribute_robust_get(&attribute, &robust);
+
+ assert_int_equal(status, F_status_set_error(statuss[i]));
+ } // for
+}
+
+void test__f_thread_mutex_attribute_robust_get__parameter_checking(void **state) {
+
+ f_thread_mutex_attribute_t attribute = f_thread_mutex_attribute_t_initialize;
+ int robust = 0;
+
+ {
+ const f_status_t status = f_thread_mutex_attribute_robust_get(0, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+
+ {
+ const f_status_t status = f_thread_mutex_attribute_robust_get(&attribute, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+
+ {
+ const f_status_t status = f_thread_mutex_attribute_robust_get(0, &robust);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_thread_mutex_attribute_robust_get__works(void **state) {
+
+ f_thread_mutex_attribute_t attribute = f_thread_mutex_attribute_t_initialize;
+ int robust = 0;
+
+ {
+ will_return(__wrap_pthread_mutexattr_getrobust, false);
+
+ const f_status_t status = f_thread_mutex_attribute_robust_get(&attribute, &robust);
+
+ 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_attribute_robust_get_h
+#define _TEST__F_thread__mutex_attribute_robust_get_h
+
+/**
+ * Test that function fails.
+ *
+ * @see f_thread_mutex_attribute_robust_get()
+ */
+extern void test__f_thread_mutex_attribute_robust_get__fails(void **state);
+
+/**
+ * Test that parameter checking works as expected.
+ *
+ * @see f_thread_mutex_attribute_robust_get()
+ */
+extern void test__f_thread_mutex_attribute_robust_get__parameter_checking(void **state);
+
+/**
+ * Test that function works.
+ *
+ * @see f_thread_mutex_attribute_robust_get()
+ */
+extern void test__f_thread_mutex_attribute_robust_get__works(void **state);
+
+#endif // _TEST__F_thread__mutex_attribute_robust_get_h
--- /dev/null
+#include "test-thread.h"
+#include "test-thread-mutex_attribute_robust_set.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_thread_mutex_attribute_robust_set__fails(void **state) {
+
+ f_thread_mutex_attribute_t attribute = f_thread_mutex_attribute_t_initialize;
+ int robust = 0;
+
+ int errnos[] = {
+ EINVAL,
+ mock_errno_generic,
+ };
+
+ f_status_t statuss[] = {
+ F_parameter,
+ F_failure,
+ };
+
+ for (uint8_t i = 0; i < 2; ++i) {
+
+ will_return(__wrap_pthread_mutexattr_setrobust, true);
+ will_return(__wrap_pthread_mutexattr_setrobust, errnos[i]);
+
+ const f_status_t status = f_thread_mutex_attribute_robust_set(robust, &attribute);
+
+ assert_int_equal(status, F_status_set_error(statuss[i]));
+ } // for
+}
+
+void test__f_thread_mutex_attribute_robust_set__parameter_checking(void **state) {
+
+ int robust = 0;
+
+ {
+ const f_status_t status = f_thread_mutex_attribute_robust_set(robust, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_thread_mutex_attribute_robust_set__works(void **state) {
+
+ f_thread_mutex_attribute_t attribute = f_thread_mutex_attribute_t_initialize;
+ int robust = 0;
+
+ {
+ will_return(__wrap_pthread_mutexattr_setrobust, false);
+
+ const f_status_t status = f_thread_mutex_attribute_robust_set(robust, &attribute);
+
+ 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_attribute_robust_set_h
+#define _TEST__F_thread__mutex_attribute_robust_set_h
+
+/**
+ * Test that function fails.
+ *
+ * @see f_thread_mutex_attribute_robust_set()
+ */
+extern void test__f_thread_mutex_attribute_robust_set__fails(void **state);
+
+/**
+ * Test that parameter checking works as expected.
+ *
+ * @see f_thread_mutex_attribute_robust_set()
+ */
+extern void test__f_thread_mutex_attribute_robust_set__parameter_checking(void **state);
+
+/**
+ * Test that function works.
+ *
+ * @see f_thread_mutex_attribute_robust_set()
+ */
+extern void test__f_thread_mutex_attribute_robust_set__works(void **state);
+
+#endif // _TEST__F_thread__mutex_attribute_robust_set_h
--- /dev/null
+#include "test-thread.h"
+#include "test-thread-mutex_consistent.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_thread_mutex_consistent__fails(void **state) {
+
+ f_thread_mutex_t mutex = f_thread_mutex_t_initialize;
+
+ int errnos[] = {
+ EINVAL,
+ mock_errno_generic,
+ };
+
+ f_status_t statuss[] = {
+ F_robust_not,
+ F_failure,
+ };
+
+ for (uint8_t i = 0; i < 2; ++i) {
+
+ will_return(__wrap_pthread_mutex_consistent, true);
+ will_return(__wrap_pthread_mutex_consistent, errnos[i]);
+
+ const f_status_t status = f_thread_mutex_consistent(&mutex);
+
+ assert_int_equal(status, F_status_set_error(statuss[i]));
+ } // for
+}
+
+void test__f_thread_mutex_consistent__parameter_checking(void **state) {
+
+ {
+ const f_status_t status = f_thread_mutex_consistent(0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_thread_mutex_consistent__works(void **state) {
+
+ f_thread_mutex_t mutex = f_thread_mutex_t_initialize;
+
+ {
+ will_return(__wrap_pthread_mutex_consistent, false);
+
+ const f_status_t status = f_thread_mutex_consistent(&mutex);
+
+ 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_consistent_h
+#define _TEST__F_thread__mutex_consistent_h
+
+/**
+ * Test that function fails.
+ *
+ * @see f_thread_mutex_consistent()
+ */
+extern void test__f_thread_mutex_consistent__fails(void **state);
+
+/**
+ * Test that parameter checking works as expected.
+ *
+ * @see f_thread_mutex_consistent()
+ */
+extern void test__f_thread_mutex_consistent__parameter_checking(void **state);
+
+/**
+ * Test that function works.
+ *
+ * @see f_thread_mutex_consistent()
+ */
+extern void test__f_thread_mutex_consistent__works(void **state);
+
+#endif // _TEST__F_thread__mutex_consistent_h
cmocka_unit_test(test__f_thread_mutex_attribute_priority_ceiling_set__fails),
cmocka_unit_test(test__f_thread_mutex_attribute_priority_ceiling_set__works),
+ cmocka_unit_test(test__f_thread_mutex_attribute_robust_get__fails),
+ cmocka_unit_test(test__f_thread_mutex_attribute_robust_get__works),
+
+ cmocka_unit_test(test__f_thread_mutex_attribute_robust_set__fails),
+ cmocka_unit_test(test__f_thread_mutex_attribute_robust_set__works),
+
cmocka_unit_test(test__f_thread_mutex_attribute_shared_get__fails),
cmocka_unit_test(test__f_thread_mutex_attribute_shared_get__works),
cmocka_unit_test(test__f_thread_mutex_attribute_protocol_set__fails),
cmocka_unit_test(test__f_thread_mutex_attribute_protocol_set__works),
+ cmocka_unit_test(test__f_thread_mutex_consistent__fails),
+ cmocka_unit_test(test__f_thread_mutex_consistent__works),
+
cmocka_unit_test(test__f_thread_mutex_create__fails),
cmocka_unit_test(test__f_thread_mutex_create__works),
cmocka_unit_test(test__f_thread_mutex_attribute_priority_ceiling_set__parameter_checking),
+ cmocka_unit_test(test__f_thread_mutex_attribute_robust_get__parameter_checking),
+
+ cmocka_unit_test(test__f_thread_mutex_attribute_robust_set__parameter_checking),
+
cmocka_unit_test(test__f_thread_mutex_attribute_shared_get__parameter_checking),
cmocka_unit_test(test__f_thread_mutex_attribute_shared_set__parameter_checking),
#include "test-thread-mutex_attribute_delete.h"
#include "test-thread-mutex_attribute_priority_ceiling_get.h"
#include "test-thread-mutex_attribute_priority_ceiling_set.h"
+#include "test-thread-mutex_attribute_robust_get.h"
+#include "test-thread-mutex_attribute_robust_set.h"
#include "test-thread-mutex_attribute_shared_get.h"
#include "test-thread-mutex_attribute_shared_set.h"
#include "test-thread-mutex_attribute_type_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_consistent.h"
#include "test-thread-mutex_create.h"
#include "test-thread-mutex_delete.h"
#include "test-thread-mutex_lock.h"
return F_okay;
}
+ if (f_compare_dynamic(name, f_status_consistent_s) == F_equal_to) {
+ *code = F_consistent;
+
+ return F_okay;
+ }
+
+ if (f_compare_dynamic(name, f_status_consistent_not_s) == F_equal_to) {
+ *code = F_consistent_not;
+
+ return F_okay;
+ }
+
if (f_compare_dynamic(name, f_status_container_s) == F_equal_to) {
*code = F_container;
return F_okay;
}
+ if (f_compare_dynamic(name, f_status_robust_s) == F_equal_to) {
+ *code = F_robust;
+
+ return F_okay;
+ }
+
+ if (f_compare_dynamic(name, f_status_robust_not_s) == F_equal_to) {
+ *code = F_robust_not;
+
+ return F_okay;
+ }
+
if (f_compare_dynamic(name, f_status_schedule_s) == F_equal_to) {
*code = F_schedule;
F_connect_not,
F_connect_refuse,
F_connect_reset,
+ F_consistent,
+ F_consistent_not,
F_container,
F_container_not,
F_content,
F_restore_not,
F_revert,
F_revert_not,
+ F_robust,
+ F_robust_not,
F_schedule,
F_schedule_not,
F_search,
f_status_connect_not_s,
f_status_connect_refuse_s,
f_status_connect_reset_s,
+ f_status_consistent_s,
+ f_status_consistent_not_s,
f_status_container_s,
f_status_container_not_s,
f_status_content_s,
f_status_restore_not_s,
f_status_revert_s,
f_status_revert_not_s,
+ f_status_robust_s,
+ f_status_robust_not_s,
f_status_schedule_s,
f_status_schedule_not_s,
f_status_search_s,
f_status_status_code_last_s,
};
- for (uint16_t i = 0; i < 664; ++i) {
+ for (uint16_t i = 0; i < 668; ++i) {
f_status_t result = F_okay;
projects / fll / commitdiff