From: Kevin Day <Kevin@kevux.org>
Date: Sun, 2 Nov 2025 22:03:15 +0000 (-0600)
Subject: Update: Provide more granular error status codes in the thread full functions.
X-Git-Tag: 0.7.3~7
X-Git-Url: https://git.kevux.org/?a=commitdiff_plain;h=340d5db44872feeca8c29e970e6091f057a76aca;p=fll

Update: Provide more granular error status codes in the thread full functions.

The LIBC pthread implementations fail to provide a way to truly verify that thread data is properly allocated or not.

The full thread types have two different thread related memory freeing functions.
If the first function fails, then the second structure is still allocated.

The previous behavior provided no way to distinguish between the two different failures.
These more granular status codes allow for such distinction now.

This allows the caller to manually try to de-allocate other parts even if the first de-allocation failed.
---

diff --git a/level_0/f_thread/c/thread/barrier_full.c b/level_0/f_thread/c/thread/barrier_full.c
index f80ee6882..c05215e42 100644
--- a/level_0/f_thread/c/thread/barrier_full.c
+++ b/level_0/f_thread/c/thread/barrier_full.c
@@ -17,11 +17,11 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_barrier);
       }
     }
 
-    return pthread_barrierattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay;
+    return pthread_barrierattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay;
   }
 #endif // _di_f_thread_barrier_full_delete_
 
diff --git a/level_0/f_thread/c/thread/barrier_full.h b/level_0/f_thread/c/thread/barrier_full.h
index 3520616ae..b7c6b8a32 100644
--- a/level_0/f_thread/c/thread/barrier_full.h
+++ b/level_0/f_thread/c/thread/barrier_full.h
@@ -42,6 +42,8 @@ extern "C" {
  * The pthread_barrier_destroy() and pthread_barrierattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project.
  * Therefore there is only this function for both deleting and destroying.
  *
+ * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called.
+ *
  * @param full
  *   The thread barrier_fulls to delete.
  *
@@ -50,10 +52,11 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a barrier is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy().
  *
- *   F_failure (with error bit) on any other error.
+ *   F_attribute (with error bit) on error when calling pthread_barrierattr_destroy().
+ *   F_barrier (with error bit) on any error when calling pthread_barrier_destroy().
  *
  * @see pthread_barrier_destroy()
  * @see pthread_barrierattr_destroy()
diff --git a/level_0/f_thread/c/thread/barrier_fulls.c b/level_0/f_thread/c/thread/barrier_fulls.c
index 9b0cd3b7c..f9248ebb5 100644
--- a/level_0/f_thread/c/thread/barrier_fulls.c
+++ b/level_0/f_thread/c/thread/barrier_fulls.c
@@ -18,10 +18,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_barrier);
       }
 
-      if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
@@ -42,10 +42,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_barrier);
       }
 
-      if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_barrierattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
diff --git a/level_0/f_thread/c/thread/barrier_fulls.h b/level_0/f_thread/c/thread/barrier_fulls.h
index 9c4c88803..a6cd8697c 100644
--- a/level_0/f_thread/c/thread/barrier_fulls.h
+++ b/level_0/f_thread/c/thread/barrier_fulls.h
@@ -45,6 +45,9 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +60,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a barrier is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_barrierattr_destroy().
+ *   F_barrier (with error bit) on any error when calling pthread_barrier_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_barrier_destroy()
  * @see pthread_barrierattr_destroy()
@@ -79,6 +84,9 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +99,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a barrier is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_barrierattr_destroy().
+ *   F_barrier (with error bit) on any error when calling pthread_barrier_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_barrier_destroy()
  * @see pthread_barrierattr_destroy()
diff --git a/level_0/f_thread/c/thread/barrier_fullss.c b/level_0/f_thread/c/thread/barrier_fullss.c
index 158238ddc..eb2df0e80 100644
--- a/level_0/f_thread/c/thread/barrier_fullss.c
+++ b/level_0/f_thread/c/thread/barrier_fullss.c
@@ -21,10 +21,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_barrier);
         }
 
-        if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
@@ -54,10 +54,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_barrier);
         }
 
-        if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_barrierattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
diff --git a/level_0/f_thread/c/thread/barrier_fullss.h b/level_0/f_thread/c/thread/barrier_fullss.h
index 552d9d338..a6e50faeb 100644
--- a/level_0/f_thread/c/thread/barrier_fullss.h
+++ b/level_0/f_thread/c/thread/barrier_fullss.h
@@ -45,6 +45,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called.
+ * When F_attribute or F_barrier (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +61,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a barrier is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_barrierattr_destroy().
+ *   F_barrier (with error bit) on any error when calling pthread_barrier_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_barrier_destroy()
  * @see pthread_barrierattr_destroy()
@@ -79,6 +85,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_barrier (with error bit) is returned, then pthread_barrierattr_destroy() is not called.
+ * When F_attribute or F_barrier (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +101,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a barrier is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a barrier is busy when calling pthread_barrier_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_barrier_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_barrierattr_destroy().
+ *   F_barrier (with error bit) on any error when calling pthread_barrier_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_barrier_destroy()
  * @see pthread_barrierattr_destroy()
diff --git a/level_0/f_thread/c/thread/condition_full.c b/level_0/f_thread/c/thread/condition_full.c
index 54433934a..801a66e5d 100644
--- a/level_0/f_thread/c/thread/condition_full.c
+++ b/level_0/f_thread/c/thread/condition_full.c
@@ -17,11 +17,11 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_condition);
       }
     }
 
-    return pthread_condattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay;
+    return pthread_condattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay;
   }
 #endif // _di_f_thread_condition_full_delete_
 
diff --git a/level_0/f_thread/c/thread/condition_full.h b/level_0/f_thread/c/thread/condition_full.h
index 1b305da6c..8316720e3 100644
--- a/level_0/f_thread/c/thread/condition_full.h
+++ b/level_0/f_thread/c/thread/condition_full.h
@@ -40,6 +40,8 @@ extern "C" {
  * The pthread_condattr_destroy() and pthread_condattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project.
  * Therefore there is only this function for both deleting and destroying.
  *
+ * When F_barrier (with error bit) is returned, then pthread_condattr_destroy() is not called.
+ *
  * @param full
  *   The full to delete.
  *
@@ -48,10 +50,11 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if the full is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy().
  *
- *   F_failure (with error bit) on any other error.
+ *   F_attribute (with error bit) on error when calling pthread_condattr_destroy().
+ *   F_condition (with error bit) on any error when calling pthread_cond_destroy().
  *
  * @see pthread_cond_destroy()
  * @see pthread_condattr_destroy()
diff --git a/level_0/f_thread/c/thread/condition_fulls.c b/level_0/f_thread/c/thread/condition_fulls.c
index e41b9b45d..fbacb4700 100644
--- a/level_0/f_thread/c/thread/condition_fulls.c
+++ b/level_0/f_thread/c/thread/condition_fulls.c
@@ -18,10 +18,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_condition);
       }
 
-      if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
@@ -42,10 +42,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_condition);
       }
 
-      if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_condattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
diff --git a/level_0/f_thread/c/thread/condition_fulls.h b/level_0/f_thread/c/thread/condition_fulls.h
index 3616831ec..e413eb31b 100644
--- a/level_0/f_thread/c/thread/condition_fulls.h
+++ b/level_0/f_thread/c/thread/condition_fulls.h
@@ -45,6 +45,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called.
+ * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +61,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a condition is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_condattr_destroy().
+ *   F_condition (with error bit) on any error when calling pthread_cond_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_cond_destroy()
  * @see pthread_condattr_destroy()
@@ -79,6 +85,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called.
+ * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +101,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a condition is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_condattr_destroy().
+ *   F_condition (with error bit) on any error when calling pthread_cond_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_cond_destroy()
  * @see pthread_condattr_destroy()
diff --git a/level_0/f_thread/c/thread/condition_fullss.c b/level_0/f_thread/c/thread/condition_fullss.c
index 584eec6cf..51328079a 100644
--- a/level_0/f_thread/c/thread/condition_fullss.c
+++ b/level_0/f_thread/c/thread/condition_fullss.c
@@ -21,10 +21,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_condition);
         }
 
-        if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
@@ -54,10 +54,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_condition);
         }
 
-        if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_condattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
diff --git a/level_0/f_thread/c/thread/condition_fullss.h b/level_0/f_thread/c/thread/condition_fullss.h
index a8aea44ca..dcc3f2834 100644
--- a/level_0/f_thread/c/thread/condition_fullss.h
+++ b/level_0/f_thread/c/thread/condition_fullss.h
@@ -45,6 +45,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called.
+ * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +61,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a condition is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_condattr_destroy().
+ *   F_condition (with error bit) on any error when calling pthread_cond_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_cond_destroy()
  * @see pthread_condattr_destroy()
@@ -79,6 +85,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_condition (with error bit) is returned, then pthread_condattr_destroy() is not called.
+ * When F_attribute or F_condition (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +101,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a condition is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_cond_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_cond_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_condattr_destroy().
+ *   F_condition (with error bit) on any error when calling pthread_cond_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_cond_destroy()
  * @see pthread_condattr_destroy()
diff --git a/level_0/f_thread/c/thread/lock_full.c b/level_0/f_thread/c/thread/lock_full.c
index f8ba15e13..6ff8fd653 100644
--- a/level_0/f_thread/c/thread/lock_full.c
+++ b/level_0/f_thread/c/thread/lock_full.c
@@ -17,11 +17,11 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_read_write);
       }
     }
 
-    return pthread_rwlockattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay;
+    return pthread_rwlockattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay;
   }
 #endif // _di_f_thread_lock_full_delete_
 
diff --git a/level_0/f_thread/c/thread/lock_full.h b/level_0/f_thread/c/thread/lock_full.h
index e960c2a71..77fcb773a 100644
--- a/level_0/f_thread/c/thread/lock_full.h
+++ b/level_0/f_thread/c/thread/lock_full.h
@@ -40,6 +40,8 @@ extern "C" {
  * The pthread_rwlock_destroy() and pthread_rwlockattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project.
  * Therefore there is only this function for both deleting and destroying.
  *
+ * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called.
+ *
  * @param full
  *   The full to delete.
  *
@@ -50,8 +52,13 @@ extern "C" {
  *
  *   F_parameter (with error bit) if a parameter is invalid.
  *
- *   F_failure (with error bit) on any other error.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy().
+ *   F_read_write (with error bit) on any error when calling pthread_rwlock_destroy().
  *
+ * @see pthread_rwlock_destroy()
  * @see pthread_rwlockattr_destroy()
  */
 #ifndef _di_f_thread_lock_full_delete_
diff --git a/level_0/f_thread/c/thread/lock_fulls.c b/level_0/f_thread/c/thread/lock_fulls.c
index f69097cc2..92187d422 100644
--- a/level_0/f_thread/c/thread/lock_fulls.c
+++ b/level_0/f_thread/c/thread/lock_fulls.c
@@ -19,10 +19,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_read_write);
       }
 
-      if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
@@ -43,10 +43,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_read_write);
       }
 
-      if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_rwlockattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
diff --git a/level_0/f_thread/c/thread/lock_fulls.h b/level_0/f_thread/c/thread/lock_fulls.h
index 37a9544aa..8d4c8136b 100644
--- a/level_0/f_thread/c/thread/lock_fulls.h
+++ b/level_0/f_thread/c/thread/lock_fulls.h
@@ -45,6 +45,8 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +59,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a lock is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy().
+ *   F_read_write (with error bit) on any error when calling pthread_rwlock_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_rwlock_destroy()
  * @see pthread_rwlockattr_destroy()
@@ -79,6 +83,8 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +97,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a lock is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy().
+ *   F_read_write (with error bit) on any error when calling pthread_rwlock_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_rwlock_destroy()
  * @see pthread_rwlockattr_destroy()
diff --git a/level_0/f_thread/c/thread/lock_fullss.c b/level_0/f_thread/c/thread/lock_fullss.c
index e08085399..7bbe47c02 100644
--- a/level_0/f_thread/c/thread/lock_fullss.c
+++ b/level_0/f_thread/c/thread/lock_fullss.c
@@ -21,10 +21,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_read_write);
         }
 
-        if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
@@ -54,10 +54,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_read_write);
         }
 
-        if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_rwlockattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
diff --git a/level_0/f_thread/c/thread/lock_fullss.h b/level_0/f_thread/c/thread/lock_fullss.h
index cb5a17c4e..295ecb4e8 100644
--- a/level_0/f_thread/c/thread/lock_fullss.h
+++ b/level_0/f_thread/c/thread/lock_fullss.h
@@ -45,6 +45,8 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +59,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a lock is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy().
+ *   F_read_write (with error bit) on any error when calling pthread_rwlock_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_rwlock_destroy()
  * @see pthread_rwlockattr_destroy()
@@ -79,6 +83,8 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_read_write (with error bit) is returned, then pthread_rwlockattr_destroy() is not called.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +97,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a lock is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a condition is busy when calling pthread_rwlock_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_rwlock_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_rwlockattr_destroy().
+ *   F_read_write (with error bit) on any error when calling pthread_rwlock_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_rwlock_destroy()
  * @see pthread_rwlockattr_destroy()
diff --git a/level_0/f_thread/c/thread/mutex_full.c b/level_0/f_thread/c/thread/mutex_full.c
index 431a575a8..e9b5dc3ad 100644
--- a/level_0/f_thread/c/thread/mutex_full.c
+++ b/level_0/f_thread/c/thread/mutex_full.c
@@ -17,11 +17,11 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_mutex);
       }
     }
 
-    return pthread_mutexattr_destroy(&full->attribute) ? F_status_set_error(F_failure) : F_okay;
+    return pthread_mutexattr_destroy(&full->attribute) ? F_status_set_error(F_attribute) : F_okay;
   }
 #endif // _di_f_thread_mutex_full_delete_
 
diff --git a/level_0/f_thread/c/thread/mutex_full.h b/level_0/f_thread/c/thread/mutex_full.h
index 350741f2f..1ce6d960a 100644
--- a/level_0/f_thread/c/thread/mutex_full.h
+++ b/level_0/f_thread/c/thread/mutex_full.h
@@ -40,6 +40,8 @@ extern "C" {
  * The pthread_mutex_destroy() and pthread_mutexattr_destroy() functions have no distinction like the *_destroy() and the *_delete() used by the FLL project.
  * Therefore there is only this function for both deleting and destroying.
  *
+ * When F_mutex (with error bit) is returned, then pthread_condattr_destroy() is not called.
+ *
  * @param full
  *   The full to delete.
  *
@@ -48,10 +50,11 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if the mutex is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy().
  *
- *   F_failure (with error bit) on any other error.
+ *   F_attribute (with error bit) on error when calling pthread_mutexattr_destroy().
+ *   F_mutex (with error bit) on any error when calling pthread_mutex_destroy().
  *
  * @see pthread_mutex_destroy()
  * @see pthread_mutexattr_destroy()
diff --git a/level_0/f_thread/c/thread/mutex_fulls.c b/level_0/f_thread/c/thread/mutex_fulls.c
index 0e2e14d5b..286eafb9d 100644
--- a/level_0/f_thread/c/thread/mutex_fulls.c
+++ b/level_0/f_thread/c/thread/mutex_fulls.c
@@ -18,10 +18,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_mutex);
       }
 
-      if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
@@ -42,10 +42,10 @@ extern "C" {
         if (error == EBUSY) return F_status_set_error(F_busy);
         if (error == EINVAL) return F_status_set_error(F_parameter);
 
-        return F_status_set_error(F_failure);
+        return F_status_set_error(F_mutex);
       }
 
-      if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_failure);
+      if (pthread_mutexattr_destroy(&array[i].attribute)) return F_status_set_error(F_attribute);
     } // for
 
     return F_okay;
diff --git a/level_0/f_thread/c/thread/mutex_fulls.h b/level_0/f_thread/c/thread/mutex_fulls.h
index 6989a801a..ae879b220 100644
--- a/level_0/f_thread/c/thread/mutex_fulls.h
+++ b/level_0/f_thread/c/thread/mutex_fulls.h
@@ -45,6 +45,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called.
+ * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +61,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a mutex is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_mutexattr_destroy().
+ *   F_mutex (with error bit) on any error when calling pthread_mutex_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_mutex_destroy()
  * @see pthread_mutexattr_destroy()
@@ -79,6 +85,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called.
+ * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +101,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a mutex is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_mutexattr_destroy().
+ *   F_mutex (with error bit) on any error when calling pthread_mutex_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_mutex_destroy()
  * @see pthread_mutexattr_destroy()
diff --git a/level_0/f_thread/c/thread/mutex_fullss.c b/level_0/f_thread/c/thread/mutex_fullss.c
index 0d766be03..e89740ea2 100644
--- a/level_0/f_thread/c/thread/mutex_fullss.c
+++ b/level_0/f_thread/c/thread/mutex_fullss.c
@@ -21,10 +21,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_mutex);
         }
 
-        if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
@@ -54,10 +54,10 @@ extern "C" {
           if (error == EBUSY) return F_status_set_error(F_busy);
           if (error == EINVAL) return F_status_set_error(F_parameter);
 
-          return F_status_set_error(F_failure);
+          return F_status_set_error(F_mutex);
         }
 
-        if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_failure);
+        if (pthread_mutexattr_destroy(&array[i].array[j].attribute)) return F_status_set_error(F_attribute);
       } // for
 
       if (array[i].size && array[i].array) {
diff --git a/level_0/f_thread/c/thread/mutex_fullss.h b/level_0/f_thread/c/thread/mutex_fullss.h
index 1abf8638a..7ac9b4251 100644
--- a/level_0/f_thread/c/thread/mutex_fullss.h
+++ b/level_0/f_thread/c/thread/mutex_fullss.h
@@ -45,6 +45,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called.
+ * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -57,13 +61,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a mutex is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_mutexattr_destroy().
+ *   F_mutex (with error bit) on any error when calling pthread_mutex_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_resize().
  *
  * @see f_memory_array_resize()
- * @see f_memory_arrays_resize()
  *
  * @see pthread_mutex_destroy()
  * @see pthread_mutexattr_destroy()
@@ -79,6 +85,10 @@ extern "C" {
  *
  * This does not do parameter checking.
  *
+ * When F_mutex (with error bit) is returned, then pthread_mutexattr_destroy() is not called.
+ * When F_attribute or F_mutex (with error bits) is returned, then f_memory_array_resize() is not called.
+ * On any error, the array is not guaranteed to be completely processed.
+ *
  * @param start
  *   The inclusive start position in the array to start deleting.
  * @param stop
@@ -91,13 +101,15 @@ extern "C" {
  * @return
  *   F_okay on success.
  *
- *   F_busy (with error bit) if a mutex is busy.
- *   F_parameter (with error bit) if a parameter is invalid.
+ *   F_busy (with error bit) if a mutex is busy when calling pthread_mutex_destroy().
+ *   F_parameter (with error bit) if a parameter is invalid (including parameter error when calling calling pthread_mutex_destroy().
+ *
+ *   F_attribute (with error bit) on error when calling pthread_mutexattr_destroy().
+ *   F_mutex (with error bit) on any error when calling pthread_mutex_destroy().
  *
  *   Errors (with error bit) from: f_memory_array_adjust().
  *
  * @see f_memory_array_adjust()
- * @see f_memory_arrays_adjust()
  *
  * @see pthread_mutex_destroy()
  * @see pthread_mutexattr_destroy()
diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c
index f2d73f571..ac75c3494 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_full_delete.c
@@ -15,10 +15,16 @@ void test__f_thread_barrier_full_delete__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_barrier,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -28,7 +34,7 @@ void test__f_thread_barrier_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -40,7 +46,7 @@ void test__f_thread_barrier_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c
index 61a972f4b..711137152 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_delete_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_barrier_fulls_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_barrier,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_barrier_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_barrier_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c
index 02ce59d36..8c88b67a2 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fulls_destroy_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_barrier_fulls_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_barrier,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_barrier_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_barrier_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c
index a1098a994..b346bbf19 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_delete_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_barrier_fullss_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_barrier,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_barrier_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_barrier_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c
index 67c34696d..b0b24ca56 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-barrier_fullss_destroy_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_barrier_fullss_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_barrier,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_barrier_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_barrier_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_barrier_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c
index 7e40b37a0..d102f785a 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-condition_full_delete.c
@@ -15,10 +15,16 @@ void test__f_thread_condition_full_delete__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_condition,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -28,7 +34,7 @@ void test__f_thread_condition_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_condition_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -40,7 +46,7 @@ void test__f_thread_condition_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_condition_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c
index 7597a45df..0c02b9e79 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_delete_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_condition_fulls_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_condition,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_condition_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_condition_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c
index bf7d09205..54d7c35e7 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fulls_destroy_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_condition_fulls_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_condition,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_condition_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_condition_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c
index 3cf49efee..731a231a9 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_delete_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_condition_fullss_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_condition,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_condition_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_condition_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c
index 9177559df..cce03efe8 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-condition_fullss_destroy_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_condition_fullss_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_condition,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_condition_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_condition_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_condition_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c
index 6fd6a762d..18117f7d5 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-lock_full_delete.c
@@ -15,10 +15,16 @@ void test__f_thread_lock_full_delete__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_read_write,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -28,7 +34,7 @@ void test__f_thread_lock_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_lock_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -40,7 +46,7 @@ void test__f_thread_lock_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_lock_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   } // for
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c
index 884b60145..71f934ca5 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_delete_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_lock_fulls_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_read_write,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_lock_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_lock_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c
index 4ce2837fb..d35bc5329 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fulls_destroy_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_lock_fulls_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_read_write,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_lock_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_lock_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c
index 64f57b6f5..d7670e195 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_delete_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_lock_fullss_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_read_write,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_lock_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_lock_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c
index 32cf0771a..47030d897 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-lock_fullss_destroy_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_lock_fullss_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_read_write,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_lock_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_lock_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_lock_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c
index 411c9b1aa..7fa3802b7 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_full_delete.c
@@ -15,10 +15,16 @@ void test__f_thread_mutex_full_delete__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
+  f_status_t statuss_1[] = {
     F_busy,
     F_parameter,
-    F_failure,
+    F_mutex,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -28,7 +34,7 @@ void test__f_thread_mutex_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -40,7 +46,7 @@ void test__f_thread_mutex_full_delete__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_full_delete(&full);
 
-    assert_int_equal(status, F_status_set_error(statuss[i]));
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c
index b657c6660..15db48062 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_delete_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_mutex_fulls_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_mutex,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_mutex_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_mutex_fulls_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fulls_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c
index 68e677f13..bdbc82d6b 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fulls_destroy_callback.c
@@ -18,10 +18,16 @@ void test__f_thread_mutex_fulls_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_mutex,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -31,7 +37,7 @@ void test__f_thread_mutex_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -43,7 +49,7 @@ void test__f_thread_mutex_fulls_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fulls_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c
index d52b04ca6..10ca0e5c8 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_delete_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_mutex_fullss_delete_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_mutex,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_mutex_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_mutex_fullss_delete_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fullss_delete_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }
 
diff --git a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c
index 3c4f1b7cf..17b92500b 100644
--- a/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-mutex_fullss_destroy_callback.c
@@ -20,10 +20,16 @@ void test__f_thread_mutex_fullss_destroy_callback__fails(void **state) {
     mock_errno_generic,
   };
 
-  f_status_t statuss[] = {
-    F_status_set_error(F_busy),
-    F_status_set_error(F_parameter),
-    F_status_set_error(F_failure),
+  f_status_t statuss_1[] = {
+    F_busy,
+    F_parameter,
+    F_mutex,
+  };
+
+  f_status_t statuss_2[] = {
+    F_busy,
+    F_parameter,
+    F_attribute,
   };
 
   for (uint8_t i = 0; i < 3; ++i) {
@@ -33,7 +39,7 @@ void test__f_thread_mutex_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_1[i]));
   } // for
 
   {
@@ -45,7 +51,7 @@ void test__f_thread_mutex_fullss_destroy_callback__fails(void **state) {
 
     const f_status_t status = f_thread_mutex_fullss_destroy_callback(0, 1, (void *) datass_array);
 
-    assert_int_equal(status, statuss[i]);
+    assert_int_equal(status, F_status_set_error(statuss_2[i]));
   }
 }