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 4431926..1c8a2cd 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 84feb6c..453c242 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 395fcd7..7f35a25 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 3a0d5c7..131777e 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 549840a..5b37b37 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 da2255b..207991d 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 e361f37..56513d9 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 c935aab..c93f3ff 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 9481a62..afd7576 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 0052c31..d9a1724 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 f8d93c2..4a028dd 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 cf453a0..06ba7e9 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 768accd..c2dc501 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 9c81a2d..bb07cd7 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 330c7ba..761f613 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 230d9d6..e9b3a7d 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 97d3e01..0d7e868 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 d00e6cb..37dd81b 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 c332a91..ee37c01 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 65f2a3b..752fd8e 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 0afc987..8a5cea4 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 79300da..7eb5c3b 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 58d9933..8e6451c 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 79c576a..b0be435 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 1e644c4..457b633 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 949fadc..efcb6c7 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 2f62f8d..1b2c8a0 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 e2041fe..1968c85 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 8fd02d7..013b2c6 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 81215f4..07bfedf 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 a85481b..7ed88ae 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 5b067ed..606a133 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 fc63302..3bb6cd1 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 7cd8cba..47fbc24 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 b29ffb5..6807a1d 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 4815fca..eeaeddf 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 2d8d3bd..dc76d61 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 038eba3..609e9b5 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 6b285fa..6b69422 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 9d43555..07d197b 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 683f09c..e6053c5 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 26272ea..0b2eec0 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 f0f9733..c57b6d9 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 449a75d..92bf47c 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 bd1f403..03a84ea 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 5adbeab..bb74d82 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 185626f..1ea4544 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 715bdcf..588ff7f 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,