Update: Use present tense for implemented (now implement) status code.

The F_implemented and F_implemented_not are now F_implement and F_implement_not respectively.

diff --git a/level_0/f_capability/c/capability.c b/level_0/f_capability/c/capability.c
index 4431926899f6a3247a676549ac32b2a027d87d34..1c8a2cd32f98a80b1786c5aeada8e053780a3e7e 100644 (file)
--- a/level_0/f_capability/c/capability.c
+++ b/level_0/f_capability/c/capability.c
@@ -12,19 +12,19 @@ extern "C" {
         if (!ambient) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_ambient_get_
 
   #ifndef _di_f_capability_ambient_reset_
     f_status_t f_capability_ambient_reset(void) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_ambient_reset_
 
   #ifndef _di_f_capability_ambient_set_
     f_status_t f_capability_ambient_set(const f_capability_value_t value, const f_capability_flag_value_t value_flag) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_ambient_set_
 
@@ -38,7 +38,7 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_clear_
 
@@ -48,13 +48,13 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_clear_flag_
 
   #ifndef _di_f_capability_compare_
     f_status_t f_capability_compare(const f_capability_t capability1, const f_capability_t capability2, int * const flags) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_compare_
 
@@ -64,7 +64,7 @@ extern "C" {
         if (!destination) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_copy_
 
@@ -74,7 +74,7 @@ extern "C" {
         if (!external) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_copy_external_
 
@@ -85,7 +85,7 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_copy_internal_
 
@@ -95,7 +95,7 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_delete_
 
@@ -105,13 +105,13 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_file_descriptor_get_
 
   #ifndef _di_f_capability_file_descriptor_set_
     f_status_t f_capability_file_descriptor_set(const int descriptor, const f_capability_t capability) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_file_descriptor_set_
 
@@ -121,13 +121,13 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_file_get_
 
   #ifndef _di_f_capability_file_set_
     f_status_t f_capability_file_set(const f_string_static_t path, const f_capability_t capability) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_file_set_
 
@@ -137,7 +137,7 @@ extern "C" {
         if (!enabled) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_flag_get_
 
@@ -147,7 +147,7 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_flag_set_
 
@@ -157,7 +157,7 @@ extern "C" {
         if (!code) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_from_name_
 
@@ -167,7 +167,7 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_from_text_
 
@@ -177,7 +177,7 @@ extern "C" {
 
   #ifndef _di_f_capability_groups_set_
     f_status_t f_capability_groups_set(const gid_t id_group, const size_t total, const gid_t id_groups[]) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_groups_set_
 
@@ -191,7 +191,7 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_initialize_
 
@@ -205,7 +205,7 @@ extern "C" {
         if (!mode) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_mode_get_
 
@@ -215,13 +215,13 @@ extern "C" {
         if (!name) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_mode_get_name_
 
   #ifndef _di_f_capability_mode_set_
     f_status_t f_capability_mode_set(const f_capability_mode_t mode) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_mode_set_
 
@@ -231,13 +231,13 @@ extern "C" {
         if (!id_user) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_owner_get_
 
   #ifndef _di_f_capability_owner_set_
     f_status_t f_capability_owner_set(const f_capability_t capability, const uid_t id_user) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_owner_set_
 
@@ -251,7 +251,7 @@ extern "C" {
         if (!bound) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_process_bound_drop_
 
@@ -261,7 +261,7 @@ extern "C" {
         if (!bound) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_process_bound_get_
 
@@ -271,7 +271,7 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_process_get_
 
@@ -281,13 +281,13 @@ extern "C" {
         if (!capability) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_process_get_by_id_
 
   #ifndef _di_f_capability_process_set_
     f_status_t f_capability_process_set(const f_capability_t capability) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_process_set_
 
@@ -301,13 +301,13 @@ extern "C" {
         if (!bits) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_security_bits_get_
 
   #ifndef _di_f_capability_security_bits_set_
     f_status_t f_capability_security_bits_set(const f_capability_bits_t bits) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_security_bits_set_
 
@@ -321,7 +321,7 @@ extern "C" {
         if (!size) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_size_
 
@@ -357,7 +357,7 @@ extern "C" {
         if (!name) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_to_name_
 
@@ -367,7 +367,7 @@ extern "C" {
         if (!text) return F_status_set_error(F_parameter);
       #endif // _di_level_0_parameter_checking_
 
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // _di_f_capability_to_text_
 
@@ -377,7 +377,7 @@ extern "C" {
 
   #ifndef f_capability_user_set
     f_status_t f_capability_user_set(const uid_t id_user) {
-      return F_status_set_error(F_implemented_not);
+      return F_status_set_error(F_implement_not);
     }
   #endif // f_capability_user_set
 

diff --git a/level_0/f_capability/c/capability.h b/level_0/f_capability/c/capability.h
index 84feb6c3ccc7d52923f9a7c3af950d182d48a048..453c24280667f42e67a9cb0dfb0aab310b50bfe7 100644 (file)
--- a/level_0/f_capability/c/capability.h
+++ b/level_0/f_capability/c/capability.h
@@ -59,7 +59,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_support_not (with error bit) if the system does not support ambient capabilities.
  *
@@ -77,7 +77,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.
@@ -101,7 +101,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.
@@ -123,7 +123,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *
  *   F_failure (with error bit) on any other failure.
@@ -145,7 +145,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *
@@ -172,7 +172,7 @@ extern "C" {
  *   F_equal_to on match.
  *   F_equal_to_not on miss.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *
  *   F_failure (with error bit) on any other failure.
@@ -195,7 +195,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *
@@ -224,7 +224,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_range_not (with error bit) on out of range when processing (external) capability.
  *
@@ -249,7 +249,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_range_not (with error bit) on out of range when processing (external) capability.
  *
@@ -271,7 +271,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory (which doesn't make sense here but man page includes this).
  *   F_parameter (with error bit) if a parameter is invalid.
  *
@@ -299,7 +299,7 @@ extern "C" {
  *   F_descriptor_not (with error bit) if the file descriptor is invalid.
  *   F_directory_not (with error bit) if a directory containing the file does not exist.
  *   F_file_found_not (with error bit) if file was not found.
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_name_not (with error bit) if the file name is too long.
  *   F_parameter (with error bit) if a parameter is invalid.
@@ -329,7 +329,7 @@ extern "C" {
  *   F_descriptor_not (with error bit) if the file descriptor is invalid.
  *   F_directory_not (with error bit) if a directory containing the file does not exist.
  *   F_file_found_not (with error bit) if file was not found.
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_name_not (with error bit) if the file name is too long.
  *   F_parameter (with error bit) if a parameter is invalid.
@@ -360,7 +360,7 @@ extern "C" {
  *   F_descriptor_not (with error bit) if the file descriptor is invalid.
  *   F_directory_not (with error bit) if a directory containing the file does not exist.
  *   F_file_found_not (with error bit) if file was not found.
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_name_not (with error bit) if the file name is too long.
  *   F_parameter (with error bit) if a parameter is invalid.
@@ -390,7 +390,7 @@ extern "C" {
  *   F_descriptor_not (with error bit) if the file descriptor is invalid.
  *   F_directory_not (with error bit) if a directory containing the file does not exist.
  *   F_file_found_not (with error bit) if file was not found.
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_name_not (with error bit) if the file name is too long.
  *   F_parameter (with error bit) if a parameter is invalid.
@@ -421,7 +421,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *
  *   F_failure (with error bit) on any other failure.
@@ -448,7 +448,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *
  *   F_failure (with error bit) on any other failure.
@@ -471,7 +471,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *
@@ -496,7 +496,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *
@@ -525,7 +525,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.
@@ -550,7 +550,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *
@@ -571,7 +571,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *
  *   F_failure (with error bit) on any other error.
  *
@@ -593,7 +593,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *
  *   F_failure (with error bit) on any other error.
  *
@@ -612,7 +612,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.
@@ -636,7 +636,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *
  *   F_failure (with error bit) on any other error.
  *
@@ -661,7 +661,7 @@ extern "C" {
  *   F_descriptor_not (with error bit) if the file descriptor is invalid.
  *   F_directory_not (with error bit) if a directory containing the file does not exist.
  *   F_file_found_not (with error bit) if file was not found.
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_name_not (with error bit) if the file name is too long.
  *   F_parameter (with error bit) if a parameter is invalid.
@@ -694,7 +694,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.
@@ -718,7 +718,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_known_not (with error bit) if the code is unknown to the current system.
  *   F_parameter (with error bit) if a parameter is invalid.
  *
@@ -740,7 +740,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *
  *   F_failure (with error bit) on any other error.
@@ -764,7 +764,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *
  *   F_failure (with error bit) on any other error.
@@ -784,7 +784,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.
@@ -806,7 +806,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *
  *   F_failure (with error bit) on any other error.
  *
@@ -825,7 +825,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.
@@ -850,7 +850,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_range_not (with error bit) on out of range when processing size.
  *
@@ -918,7 +918,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_string_too_large (with error bit) if appended string length is too large to store in the buffer.
@@ -950,7 +950,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_string_too_large (with error bit) if appended string length is too large to store in the buffer.
@@ -982,7 +982,7 @@ extern "C" {
  * @return
  *   F_none on success.
  *
- *   F_implemented_not (with error bit) if this function is not available (due to not having libcap support compiled in).
+ *   F_implement_not (with error bit) if this function is not available (due to not having libcap support compiled in).
  *   F_memory_not (with error bit) if a out of memory.
  *   F_parameter (with error bit) if a parameter is invalid.
  *   F_prohibited (with error bit) if the file system does not permit this operation.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c b/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c
index 395fcd796e5ac2fecf97be54a1538e91687d56e6..7f35a25683c6f7ab0fceb847472fce7daccf9fc2 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c
@@ -48,7 +48,7 @@ void test__f_capability_ambient_get__works(void **state) {
     const f_status_t status = f_capability_ambient_get(value, &ambient);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(ambient, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-ambient_reset.c b/level_0/f_capability/tests/unit/c/test-capability-ambient_reset.c
index 3a0d5c7dcb36a4d85d61f4539c25a985feec7a2b..131777ec04a3172204b6b5709d79a8e74d00a99e 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-ambient_reset.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-ambient_reset.c
@@ -53,7 +53,7 @@ void test__f_capability_ambient_reset__works(void **state) {
     const f_status_t status = f_capability_ambient_reset();
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-ambient_set.c b/level_0/f_capability/tests/unit/c/test-capability-ambient_set.c
index 549840aa151787d8e950b014a604b1cd93378454..5b37b37d761a325d779324763eb5497f293a0c94 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-ambient_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-ambient_set.c
@@ -50,7 +50,7 @@ void test__f_capability_ambient_set__works(void **state) {
     const f_status_t status = f_capability_ambient_set(value, flag_value);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-clear.c b/level_0/f_capability/tests/unit/c/test-capability-clear.c
index da2255be5ea6db5ed71048da721404fb4d5bafc7..207991d599f62d10a9b7e65ddf019fae856044f5 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-clear.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-clear.c
@@ -59,7 +59,7 @@ void test__f_capability_clear__works(void **state) {
     const f_status_t status = f_capability_clear(&capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c b/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c
index e361f372298c316f3ddeef0afef8316ae4ce5248..56513d967b48cd709fee08dc4bb381e3a942bda5 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c
@@ -33,7 +33,7 @@ void test__f_capability_clear_flag__works(void **state) {
     const f_status_t status = f_capability_clear_flag(flag, &capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-compare.c b/level_0/f_capability/tests/unit/c/test-capability-compare.c
index c935aab81570eab5b1e8255759bad90d0030aaf9..c93f3fff3ae80c378b7a4b4cdb5c7a75d776ff19 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-compare.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-compare.c
@@ -46,7 +46,7 @@ void test__f_capability_compare__works(void **state) {
     {
       const f_status_t status = f_capability_compare(capability_1, capability_2, &flags);
 
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     }
   #else
     {

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy.c b/level_0/f_capability/tests/unit/c/test-capability-copy.c
index 9481a6204b9e382a1b02545bbda4c802da81e5bd..afd757638a3b55e999731c71d198626634d4a75e 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy.c
@@ -49,7 +49,7 @@ void test__f_capability_copy__works(void **state) {
     const f_status_t status = f_capability_copy(capability_1, &capability_2);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(capability_2, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy_external.c b/level_0/f_capability/tests/unit/c/test-capability-copy_external.c
index 0052c310f1f4fa14caaa3762bd93b13ed7e63e51..d9a172488cfb2437f6bc9444e245fffa29ddf501 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy_external.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy_external.c
@@ -67,7 +67,7 @@ void test__f_capability_copy_external__works(void **state) {
     const f_status_t status = f_capability_copy_external(capability, max, external, &size);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(size, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c b/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c
index f8d93c2abd99e400b23e4c9071a0bec927f274c3..4a028ddd90637af4d00fefffa45d040cf5ca6295 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c
@@ -71,7 +71,7 @@ void test__f_capability_copy_internal__works(void **state) {
     const f_status_t status = f_capability_copy_internal(external, &capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(capability, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-delete.c b/level_0/f_capability/tests/unit/c/test-capability-delete.c
index cf453a0f3dbfa8afc6f587cc0b2f4c6f76dcb81c..06ba7e90aedd383bf1708528b7d215ede9067ab6 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-delete.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-delete.c
@@ -57,7 +57,7 @@ void test__f_capability_delete__works(void **state) {
     const f_status_t status = f_capability_delete(&capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(capability, 0);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c
index 768accdd6b22c62f50bcf40b2a95c9f5b77c90f8..c2dc501e424fe0f65503fe31b16a2df99af822e6 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c
@@ -73,7 +73,7 @@ void test__f_capability_file_descriptor_get__works(void **state) {
     const f_status_t status = f_capability_file_descriptor_get(descriptor, &capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_set.c b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_set.c
index 9c81a2ddfca32c7bd17721a0e0e658e970c1e7d4..bb07cd7d505e0ba4a2a46c5364bb3c7f0577c5b9 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_set.c
@@ -62,7 +62,7 @@ void test__f_capability_file_descriptor_set__works(void **state) {
     const f_status_t status = f_capability_file_descriptor_set(descriptor, capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_get.c b/level_0/f_capability/tests/unit/c/test-capability-file_get.c
index 330c7ba6ccbbcc40e5eee3c81bf94e184146a42c..761f613d84d7d5ca19d7261c90675fc028494e7d 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_get.c
@@ -73,7 +73,7 @@ void test__f_capability_file_get__works(void **state) {
     const f_status_t status = f_capability_file_get(path, &capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_set.c b/level_0/f_capability/tests/unit/c/test-capability-file_set.c
index 230d9d6308d678d412b0a7c9d83707c66886d5a8..e9b3a7d88aaa9f38c3e0781b0f9847c7d9af6b59 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_set.c
@@ -62,7 +62,7 @@ void test__f_capability_file_set__works(void **state) {
     const f_status_t status = f_capability_file_set(path, capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-flag_get.c b/level_0/f_capability/tests/unit/c/test-capability-flag_get.c
index 97d3e01d08b497cc9d61b359f704eed4f93b2a21..0d7e868c36220e5f9c3a47701d07053f5cbcfea8 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-flag_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-flag_get.c
@@ -65,7 +65,7 @@ void test__f_capability_flag_get__works(void **state) {
     const f_status_t status = f_capability_flag_get(capability, capability_value, flag, &value);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-flag_set.c b/level_0/f_capability/tests/unit/c/test-capability-flag_set.c
index d00e6cb369167ce532655cf9d96e148d9bcf725b..37dd81bf402cf379da19aa887e57064e824aaf85 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-flag_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-flag_set.c
@@ -65,7 +65,7 @@ void test__f_capability_flag_set__works(void **state) {
     const f_status_t status = f_capability_flag_set(flag, value, codes, &capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-from_name.c b/level_0/f_capability/tests/unit/c/test-capability-from_name.c
index c332a91045ff2ff9f9e4f91d6dcf9980b41e8d00..ee37c016b0e33bf4585d139a82ca4666eb460394 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-from_name.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-from_name.c
@@ -61,7 +61,7 @@ void test__f_capability_from_name__works(void **state) {
     const f_status_t status = f_capability_from_name(name, &capability_value);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-from_text.c b/level_0/f_capability/tests/unit/c/test-capability-from_text.c
index 65f2a3b751015cb501c9bab44fd8a7dc4b3c9211..752fd8efeaa8ae7c658dbadc6681ad2edfe8e934 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-from_text.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-from_text.c
@@ -61,7 +61,7 @@ void test__f_capability_from_text__works(void **state) {
     const f_status_t status = f_capability_from_text(text, &capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-groups_set.c b/level_0/f_capability/tests/unit/c/test-capability-groups_set.c
index 0afc9879304c2af69efea78de0ceb70899897df2..8a5cea446343a3e35e6f48ba8dd0836f552046e4 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-groups_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-groups_set.c
@@ -54,7 +54,7 @@ void test__f_capability_groups_set__works(void **state) {
     const f_status_t status = f_capability_groups_set(group, total, groups);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-initialize.c b/level_0/f_capability/tests/unit/c/test-capability-initialize.c
index 79300dafe2030a64a8a7745d13d7cd3d7d99ff0f..7eb5c3be1b77a0cad6183111791b887edbe71373 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-initialize.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-initialize.c
@@ -57,7 +57,7 @@ void test__f_capability_initialize__works(void **state) {
     const f_status_t status = f_capability_initialize(&capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-mode_get.c b/level_0/f_capability/tests/unit/c/test-capability-mode_get.c
index 58d9933bfa97bf840cd6ed52071867b178439a62..8e6451c111a945557d07b39512a32a90136d9b3a 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-mode_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-mode_get.c
@@ -28,7 +28,7 @@ void test__f_capability_mode_get__works(void **state) {
     const f_status_t status = f_capability_mode_get(&mode);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c b/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c
index 79c576afaa0657da52fd24800b68a70f80d6eec3..b0be43541e2c536fe430b4e0aef83c0289317437 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c
@@ -31,7 +31,7 @@ void test__f_capability_mode_get_name__works(void **state) {
     const f_status_t status = f_capability_mode_get_name(mode, &name);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-mode_set.c b/level_0/f_capability/tests/unit/c/test-capability-mode_set.c
index 1e644c46863501e99bebe007acb3d0a3c7295633..457b633acf14351554c41e85f969502e821ab3a3 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-mode_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-mode_set.c
@@ -50,7 +50,7 @@ void test__f_capability_mode_set__works(void **state) {
     const f_status_t status = f_capability_mode_set(mode);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-owner_get.c b/level_0/f_capability/tests/unit/c/test-capability-owner_get.c
index 949fadc0f4a7a7a9d1595600da90a749707cce9a..efcb6c70558837e0d90b86ef9a2e7afc75a3d42a 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-owner_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-owner_get.c
@@ -31,7 +31,7 @@ void test__f_capability_owner_get__works(void **state) {
     const f_status_t status = f_capability_owner_get(capability, &id);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(id, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-owner_set.c b/level_0/f_capability/tests/unit/c/test-capability-owner_set.c
index 2f62f8dcd61d9dbd5149f0578f6b1f97b2b884c2..1b2c8a0fdceccf5bd4f7d82e76e289013c22f9f3 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-owner_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-owner_set.c
@@ -62,7 +62,7 @@ void test__f_capability_owner_set__works(void **state) {
     const f_status_t status = f_capability_owner_set(capability, id);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c b/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c
index e2041fec239f58df6ca10425a2209f8c3d93fc52..1968c857c9301d742a73d53d390fc2ba06726bd7 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c
@@ -63,7 +63,7 @@ void test__f_capability_process_bound_drop__works(void **state) {
     const f_status_t status = f_capability_process_bound_drop(value, &bound);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(bound, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c b/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c
index 8fd02d71a0dfb8c72cf78ba48a21ac3ac86a25b2..013b2c6c47097ea30c2ebe288cc639a1ab4f9b99 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c
@@ -57,7 +57,7 @@ void test__f_capability_process_bound_get__works(void **state) {
     const f_status_t status = f_capability_process_bound_get(value, &bound);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(bound, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_get.c b/level_0/f_capability/tests/unit/c/test-capability-process_get.c
index 81215f48cf818e17f9d2c0d1acce7b9eae587dc1..07bfedf5ec02bcd9b4309b0de8dd0fbcb10063f7 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_get.c
@@ -57,7 +57,7 @@ void test__f_capability_process_get__works(void **state) {
     const f_status_t status = f_capability_process_get(&capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c b/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c
index a85481bcbf8bcbd7745ad029b48fb9b1d51d62b7..7ed88ae6c98605c919354e919c014f4a0a1cad30 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c
@@ -55,7 +55,7 @@ void test__f_capability_process_get_by_id__works(void **state) {
     const f_status_t status = f_capability_process_get_by_id(pid, &capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(capability, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_set.c b/level_0/f_capability/tests/unit/c/test-capability-process_set.c
index 5b067edfe38c34a4d3a2493de11e1ff7144c87f0..606a1339b5b73be9253be226199d9d3e76d4f4d6 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_set.c
@@ -50,7 +50,7 @@ void test__f_capability_process_set__works(void **state) {
     const f_status_t status = f_capability_process_set(capability);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c b/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c
index fc63302ee0e4f18f0b9b316d0691cf2bdc870b58..3bb6cd19e22920306cce5e82ad882ecb530a690c 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c
@@ -59,7 +59,7 @@ void test__f_capability_security_bits_get__works(void **state) {
     const f_status_t status = f_capability_security_bits_get(&bits);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-security_bits_set.c b/level_0/f_capability/tests/unit/c/test-capability-security_bits_set.c
index 7cd8cbaffbba365aeeff59b3a6d839b7e27e1765..47fbc246e5d612ed7925f743560a38f84b20601d 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-security_bits_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-security_bits_set.c
@@ -60,7 +60,7 @@ void test__f_capability_security_bits_set__works(void **state) {
     const f_status_t status = f_capability_security_bits_set(bits);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_capability/tests/unit/c/test-capability-size.c b/level_0/f_capability/tests/unit/c/test-capability-size.c
index b29ffb5b4ce0067c1d17112b771c0294f3883d9d..6807a1de3629d8a0a037930b396d9517a4d6e9ff 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-size.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-size.c
@@ -63,7 +63,7 @@ void test__f_capability_size__works(void **state) {
     const f_status_t status = f_capability_size(capability, &size);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_int_equal(size, 1);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-to_name.c b/level_0/f_capability/tests/unit/c/test-capability-to_name.c
index 4815fca2d769398b73670ca3602c924d1b32c0f0..eeaeddf3f244bec51d49879a0d4a9377ec113c93 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-to_name.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-to_name.c
@@ -65,7 +65,7 @@ void test__f_capability_to_name__works(void **state) {
     const f_status_t status = f_capability_to_name(code, &name);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_string_equal(name.string, string);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-to_text.c b/level_0/f_capability/tests/unit/c/test-capability-to_text.c
index 2d8d3bd357654ed20bdbd01e711875b1ab309659..dc76d61bbfc7210745f9df76d76cc3de0ad94642 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-to_text.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-to_text.c
@@ -66,7 +66,7 @@ void test__f_capability_to_text__works(void **state) {
     const f_status_t status = f_capability_to_text(capability, &text);
 
     #if defined(_di_libcap_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
       assert_string_equal(text.string, string);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-user_set.c b/level_0/f_capability/tests/unit/c/test-capability-user_set.c
index 038eba37afd94fdb860d36d152fb81c44b292dd1..609e9b5c2f8cb013cd60f62e3aca561691870399 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-user_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-user_set.c
@@ -19,7 +19,7 @@ void test__f_capability_user_set__works(void **state) {
     const f_status_t status = f_capability_user_set(uid);
 
     #if defined(_di_libcap_) || defined(_libcap_legacy_only_)
-      assert_int_equal(F_status_set_fine(status), F_implemented_not);
+      assert_int_equal(F_status_set_fine(status), F_implement_not);
     #else
       assert_int_equal(status, F_none);
     #endif // defined(_di_libcap_) || defined(_libcap_legacy_only_)

diff --git a/level_0/f_status/c/status.h b/level_0/f_status/c/status.h
index 6b285fa8e3a3f2c6e2fed937a6ceeecd8884c2c1..6b69422e2f526d83a3dc4e8dee5b331706c7c758 100644 (file)
--- a/level_0/f_status/c/status.h
+++ b/level_0/f_status/c/status.h
@@ -329,8 +329,8 @@ extern "C" {
       F_help_not,
       F_ignore,
       F_ignore_not,
-      F_implemented,
-      F_implemented_not,
+      F_implement,
+      F_implement_not,
       F_input,
       F_input_not,
       F_input_output,

diff --git a/level_0/f_status_string/c/status_string.c b/level_0/f_status_string/c/status_string.c
index 9d4355591559d7172e9a8ad68d49cf7b07ca8747..07d197b2dcacd6204a37ffaf7e0b976ed230b07a 100644 (file)
--- a/level_0/f_status_string/c/status_string.c
+++ b/level_0/f_status_string/c/status_string.c
@@ -203,8 +203,8 @@ extern "C" {
     const f_string_static_t f_status_help_not_s = macro_f_string_static_t_initialize_1(F_status_help_not_s, 0, F_status_help_not_s_length);
     const f_string_static_t f_status_ignore_s = macro_f_string_static_t_initialize_1(F_status_ignore_s, 0, F_status_ignore_s_length);
     const f_string_static_t f_status_ignore_not_s = macro_f_string_static_t_initialize_1(F_status_ignore_not_s, 0, F_status_ignore_not_s_length);
-    const f_string_static_t f_status_implemented_s = macro_f_string_static_t_initialize_1(F_status_implemented_s, 0, F_status_implemented_s_length);
-    const f_string_static_t f_status_implemented_not_s = macro_f_string_static_t_initialize_1(F_status_implemented_not_s, 0, F_status_implemented_not_s_length);
+    const f_string_static_t f_status_implement_s = macro_f_string_static_t_initialize_1(F_status_implement_s, 0, F_status_implement_s_length);
+    const f_string_static_t f_status_implement_not_s = macro_f_string_static_t_initialize_1(F_status_implement_not_s, 0, F_status_implement_not_s_length);
     const f_string_static_t f_status_input_s = macro_f_string_static_t_initialize_1(F_status_input_s, 0, F_status_input_s_length);
     const f_string_static_t f_status_input_not_s = macro_f_string_static_t_initialize_1(F_status_input_not_s, 0, F_status_input_not_s_length);
     const f_string_static_t f_status_input_output_s = macro_f_string_static_t_initialize_1(F_status_input_output_s, 0, F_status_input_output_s_length);
@@ -1640,13 +1640,13 @@ extern "C" {
 
           break;
 
-        case F_implemented:
-          *name = f_status_implemented_s;
+        case F_implement:
+          *name = f_status_implement_s;
 
           break;
 
-        case F_implemented_not:
-          *name = f_status_implemented_not_s;
+        case F_implement_not:
+          *name = f_status_implement_not_s;
 
           break;
 

diff --git a/level_0/f_status_string/c/status_string.h b/level_0/f_status_string/c/status_string.h
index 683f09c0a243f5e0a1960a6beed1157db0687c0f..e6053c50174e7d288d77fc343f56ceeed4d0199d 100644 (file)
--- a/level_0/f_status_string/c/status_string.h
+++ b/level_0/f_status_string/c/status_string.h
@@ -356,8 +356,8 @@ extern "C" {
     #define F_status_help_not_s          "F_help_not"
     #define F_status_ignore_s            "F_ignore"
     #define F_status_ignore_not_s        "F_ignore_not"
-    #define F_status_implemented_s       "F_implemented"
-    #define F_status_implemented_not_s   "F_implemented_not"
+    #define F_status_implement_s         "F_implement"
+    #define F_status_implement_not_s     "F_implement_not"
     #define F_status_input_s             "F_input"
     #define F_status_input_not_s         "F_input_not"
     #define F_status_input_output_s      "F_input_output"
@@ -666,8 +666,8 @@ extern "C" {
     #define F_status_help_not_s_length          10
     #define F_status_ignore_s_length            8
     #define F_status_ignore_not_s_length        12
-    #define F_status_implemented_s_length       13
-    #define F_status_implemented_not_s_length   17
+    #define F_status_implement_s_length         11
+    #define F_status_implement_not_s_length     15
     #define F_status_input_s_length             7
     #define F_status_input_not_s_length         11
     #define F_status_input_output_s_length      14
@@ -978,8 +978,8 @@ extern "C" {
     extern const f_string_static_t f_status_help_not_s;
     extern const f_string_static_t f_status_ignore_s;
     extern const f_string_static_t f_status_ignore_not_s;
-    extern const f_string_static_t f_status_implemented_s;
-    extern const f_string_static_t f_status_implemented_not_s;
+    extern const f_string_static_t f_status_implement_s;
+    extern const f_string_static_t f_status_implement_not_s;
     extern const f_string_static_t f_status_input_s;
     extern const f_string_static_t f_status_input_not_s;
     extern const f_string_static_t f_status_input_output_s;

diff --git a/level_0/f_status_string/tests/unit/c/test-status_string-to.c b/level_0/f_status_string/tests/unit/c/test-status_string-to.c
index 26272ea99e4be689b788bb2569e1312f72bf6334..0b2eec0455f08d5e46eca82edaaa673425ece036 100644 (file)
--- a/level_0/f_status_string/tests/unit/c/test-status_string-to.c
+++ b/level_0/f_status_string/tests/unit/c/test-status_string-to.c
@@ -221,8 +221,8 @@ void test__f_status_string_to__works(void **state) {
     F_help_not,
     F_ignore,
     F_ignore_not,
-    F_implemented,
-    F_implemented_not,
+    F_implement,
+    F_implement_not,
     F_input,
     F_input_not,
     F_input_output,
@@ -835,8 +835,8 @@ void test__f_status_string_to__works(void **state) {
     f_status_help_not_s,
     f_status_ignore_s,
     f_status_ignore_not_s,
-    f_status_implemented_s,
-    f_status_implemented_not_s,
+    f_status_implement_s,
+    f_status_implement_not_s,
     f_status_input_s,
     f_status_input_not_s,
     f_status_input_output_s,

diff --git a/level_0/f_thread/c/thread.c b/level_0/f_thread/c/thread.c
index f0f9733506482a8bbbb3fb6637f4c4d1647bf0fc..c57b6d9db904be65e8a33c11a0abe8244e842c7b 100644 (file)
--- a/level_0/f_thread/c/thread.c
+++ b/level_0/f_thread/c/thread.c
@@ -31,7 +31,7 @@ extern "C" {
       if (!affinity_set) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
-    return F_status_set_error(F_implemented_not);
+    return F_status_set_error(F_implement_not);
   }
 #elif !defined(_di_f_thread_attribute_affinity_get_)
   f_status_t f_thread_attribute_affinity_get(const f_thread_attribute_t attribute, const size_t affinity_size, cpu_set_t * const affinity_set) {
@@ -57,7 +57,7 @@ extern "C" {
       if (!attribute) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
-    return F_status_set_error(F_implemented_not);
+    return F_status_set_error(F_implement_not);
   }
 #elif !defined(_di_f_thread_attribute_affinity_set_)
   f_status_t f_thread_attribute_affinity_set(const size_t affinity_size, const cpu_set_t *affinity_set, f_thread_attribute_t * const attribute) {
@@ -1887,7 +1887,7 @@ extern "C" {
 #if defined(_pthread_sigqueue_unsupported_) && !defined(_di_f_thread_signal_queue_)
   f_status_t f_thread_signal_queue(const f_thread_id_t id, const int signal, const union sigval value) {
 
-    return F_status_set_error(F_implemented_not);
+    return F_status_set_error(F_implement_not);
   }
 #elif !defined(_di_f_thread_signal_queue_)
   f_status_t f_thread_signal_queue(const f_thread_id_t id, const int signal, const union sigval value) {

diff --git a/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_get.c b/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_get.c
index 449a75d00012d7a9a27ac224b49d8673aff6eee7..92bf47c9c1c08b049563ebee3dd2b8e7beba413d 100644 (file)
--- a/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_get.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_get.c
@@ -15,7 +15,7 @@ void test__f_thread_attribute_affinity_get__fails(void **state) {
   #if defined(_pthread_attr_unsupported_)
     const f_status_t status = f_thread_attribute_affinity_get(attribute, 0, &cpu_set);
 
-    assert_int_equal(status, F_status_set_error(F_implemented_not));
+    assert_int_equal(status, F_status_set_error(F_implement_not));
   #else
     int errnos[] = {
       EINVAL,
@@ -61,7 +61,7 @@ void test__f_thread_attribute_affinity_get__works(void **state) {
     {
       const f_status_t status = f_thread_attribute_affinity_get(attribute, 0, &cpu_set);
 
-      assert_int_equal(status, F_status_set_error(F_implemented_not));
+      assert_int_equal(status, F_status_set_error(F_implement_not));
     }
   #else
     {

diff --git a/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_set.c b/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_set.c
index bd1f403a8ac950999693a5dd7486cdb33d295811..03a84ea7bf270bf7e8c19a2a6dfb48998969af17 100644 (file)
--- a/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_set.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-attribute_affinity_set.c
@@ -15,7 +15,7 @@ void test__f_thread_attribute_affinity_set__fails(void **state) {
   #if defined(_pthread_attr_unsupported_)
     const f_status_t status = f_thread_attribute_affinity_set(0, &cpu_set, &attribute);
 
-    assert_int_equal(status, F_status_set_error(F_implemented_not));
+    assert_int_equal(status, F_status_set_error(F_implement_not));
   #else
     int errnos[] = {
       EINVAL,
@@ -65,7 +65,7 @@ void test__f_thread_attribute_affinity_set__works(void **state) {
     {
       const f_status_t status = f_thread_attribute_affinity_set(0, &cpu_set, &attribute);
 
-      assert_int_equal(status, F_status_set_error(F_implemented_not));
+      assert_int_equal(status, F_status_set_error(F_implement_not));
     }
   #else
     {

diff --git a/level_0/f_thread/tests/unit/c/test-thread-signal_queue.c b/level_0/f_thread/tests/unit/c/test-thread-signal_queue.c
index 5adbeab69656de8bb72d461ca6ca8eda8a47427b..bb74d82980b20b636cea6901e1f84b524514915f 100644 (file)
--- a/level_0/f_thread/tests/unit/c/test-thread-signal_queue.c
+++ b/level_0/f_thread/tests/unit/c/test-thread-signal_queue.c
@@ -16,7 +16,7 @@ void test__f_thread_signal_queue__fails(void **state) {
   #ifdef _pthread_sigqueue_unsupported_
     const f_status_t status = f_thread_signal_queue(id, signal, value);
 
-    assert_int_equal(status, F_status_set_error(F_implemented_not));
+    assert_int_equal(status, F_status_set_error(F_implement_not));
   #else
     {
       int errnos[] = {
@@ -59,7 +59,7 @@ void test__f_thread_signal_queue__works(void **state) {
   #ifdef _pthread_sigqueue_unsupported_
     const f_status_t status = f_thread_signal_queue(id, signal, value);
 
-    assert_int_equal(status, F_status_set_error(F_implemented_not));
+    assert_int_equal(status, F_status_set_error(F_implement_not));
   #else
     {
       will_return(__wrap_pthread_sigqueue, false);

diff --git a/level_1/fl_status_string/c/status_string.c b/level_1/fl_status_string/c/status_string.c
index 185626f44bc0838661fdf4d04b82fd9d928a0886..1ea454466d8cfd141108c0a8051d1012e0606d12 100644 (file)
--- a/level_1/fl_status_string/c/status_string.c
+++ b/level_1/fl_status_string/c/status_string.c
@@ -1169,14 +1169,14 @@ extern "C" {
         return F_none;
       }
 
-      if (f_compare_dynamic(name, f_status_implemented_s) == F_equal_to) {
-        *code = F_implemented;
+      if (f_compare_dynamic(name, f_status_implement_s) == F_equal_to) {
+        *code = F_implement;
 
         return F_none;
       }
 
-      if (f_compare_dynamic(name, f_status_implemented_not_s) == F_equal_to) {
-        *code = F_implemented_not;
+      if (f_compare_dynamic(name, f_status_implement_not_s) == F_equal_to) {
+        *code = F_implement_not;
 
         return F_none;
       }

diff --git a/level_1/fl_status_string/tests/unit/c/test-status_string-from.c b/level_1/fl_status_string/tests/unit/c/test-status_string-from.c
index 715bdcf31fa563630b24650e5be6ff9cda486f54..588ff7f342a567d1ddd5dfd75ebc184de23a0dc5 100644 (file)
--- a/level_1/fl_status_string/tests/unit/c/test-status_string-from.c
+++ b/level_1/fl_status_string/tests/unit/c/test-status_string-from.c
@@ -237,8 +237,8 @@ void test__fl_status_string_from__works(void **state) {
     F_help_not,
     F_ignore,
     F_ignore_not,
-    F_implemented,
-    F_implemented_not,
+    F_implement,
+    F_implement_not,
     F_input,
     F_input_not,
     F_input_output,
@@ -851,8 +851,8 @@ void test__fl_status_string_from__works(void **state) {
     f_status_help_not_s,
     f_status_ignore_s,
     f_status_ignore_not_s,
-    f_status_implemented_s,
-    f_status_implemented_not_s,
+    f_status_implement_s,
+    f_status_implement_not_s,
     f_status_input_s,
     f_status_input_not_s,
     f_status_input_output_s,