This provides changes that were documented in that commit.

Use the `^` operator (XOR) to determine if mode is different or the same.

Add file mode program unit tests.

diff --git a/data/build/remove/settings-tests.remove b/data/build/remove/settings-tests.remove
index 12896a8d2c2debbd94559e82908a2e15b475f8b2..08fe50cea6b61dfd9935d61f51da21ce27d9c759 100644 (file)
--- a/data/build/remove/settings-tests.remove
+++ b/data/build/remove/settings-tests.remove
@@ -31,7 +31,7 @@ build_libraries-individual_thread -lf_thread
 
 build_sources_program test-remove.c
 build_sources_program test-remove-print_help.c test-remove-print_version.c
-build_sources_program test-remove-file_type.c
+build_sources_program test-remove-file_mode.c test-remove-file_type.c
 build_sources_program test-remove-group.c
 build_sources_program test-remove-directory_no_args.c test-remove-directory_recurse_simple.c test-remove-directory_tree_simple.c
 build_sources_program test-remove-regular_no_args.c

diff --git a/sources/c/program/kevux/tools/remove/main/preprocess.c b/sources/c/program/kevux/tools/remove/main/preprocess.c
index 8a382ed7db16be991a4881c22b5d73eec9f946ce..002e97025728a4db3ab792718f2dc8b441d3d350 100644 (file)
--- a/sources/c/program/kevux/tools/remove/main/preprocess.c
+++ b/sources/c/program/kevux/tools/remove/main/preprocess.c
@@ -183,10 +183,10 @@ extern "C" {
         if (kt_remove_signal_check(main)) return flag_out;
 
         if (main->setting.modes.array[i].type == kt_remove_flag_mode_different_d) {
-          if (main->setting.modes.array[i].mode & ~mode) break;
+          if (main->setting.modes.array[i].mode ^ mode) break;
         }
         else if (main->setting.modes.array[i].type == kt_remove_flag_mode_same_d) {
-          if (main->setting.modes.array[i].mode == mode) break;
+          if (!(main->setting.modes.array[i].mode ^ mode)) break;
         }
         else if (main->setting.modes.array[i].type == kt_remove_flag_mode_similar_d) {
           if (main->setting.modes.array[i].mode & mode) break;

diff --git a/sources/c/program/kevux/tools/remove/main/print/simulate.c b/sources/c/program/kevux/tools/remove/main/print/simulate.c
index f1211822837193facc354bc5f557893ef7f6cb97..df3edc9321562f9540e60c5e0f046c5bfaa0bcc4 100644 (file)
--- a/sources/c/program/kevux/tools/remove/main/print/simulate.c
+++ b/sources/c/program/kevux/tools/remove/main/print/simulate.c
@@ -192,15 +192,29 @@ extern "C" {
     if (main->setting.flag & kt_remove_main_flag_mode_d) {
       const mode_t mode = statistics.st_mode & F_file_mode_all_d;
 
+      const uint8_t types[] = {
+        kt_remove_flag_mode_different_d,
+        kt_remove_flag_mode_same_d,
+        kt_remove_flag_mode_similar_d,
+        kt_remove_flag_mode_not_d,
+      };
+
+      const f_string_static_t strings[] = {
+        kt_remove_mode_word_different_s,
+        kt_remove_mode_word_same_s,
+        kt_remove_mode_word_similar_s,
+        kt_remove_mode_word_not_s,
+      };
+
       fll_print_format("  mode %@03un%r", print->to, (f_number_unsigned_t) mode, f_string_eol_s);
 
       for (i = 0; i < main->setting.modes.used; ++i) {
 
         if (main->setting.modes.array[i].type == kt_remove_flag_mode_different_d) {
-          if (main->setting.modes.array[i].mode & ~mode) break;
+          if (main->setting.modes.array[i].mode ^ mode) break;
         }
         else if (main->setting.modes.array[i].type == kt_remove_flag_mode_same_d) {
-          if (main->setting.modes.array[i].mode == mode) break;
+          if (!(main->setting.modes.array[i].mode ^ mode)) break;
         }
         else if (main->setting.modes.array[i].type == kt_remove_flag_mode_similar_d) {
           if (main->setting.modes.array[i].mode & mode) break;
@@ -211,20 +225,6 @@ extern "C" {
       } // for
 
       if (i < main->setting.modes.used) {
-        uint8_t types[] = {
-          kt_remove_flag_mode_different_d,
-          kt_remove_flag_mode_same_d,
-          kt_remove_flag_mode_similar_d,
-          kt_remove_flag_mode_not_d,
-        };
-
-        f_string_static_t strings[] = {
-          kt_remove_mode_word_different_s,
-          kt_remove_mode_word_same_s,
-          kt_remove_mode_word_similar_s,
-          kt_remove_mode_word_not_s,
-        };
-
         for (j = 0; j < 4; ++j) {
 
           if (main->setting.modes.array[i].type == types[j]) {

diff --git a/tests/unit/remove/c/test-remove-file_mode.c b/tests/unit/remove/c/test-remove-file_mode.c
new file mode 100644 (file)
index 0000000..fe4a726
--- /dev/null
+++ b/tests/unit/remove/c/test-remove-file_mode.c
@@ -0,0 +1,432 @@
+#include "test-remove.h"
+#include "test-remove-file_mode.h"
+
+#include <program/kevux/tools/remove/remove/main.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__kt_remove__file_mode__different_works(void **state) {
+
+  mock_unwrap = 0;
+
+  const f_string_static_t target = macro_f_string_static_t_initialize_1("to_remove", 0, 9);
+
+  const uint8_t types_total = 8;
+  const uint8_t modes_total = 10; // For both modes and params.
+
+  const int32_t types[] = {
+    F_file_type_block_d,
+    F_file_type_character_d,
+    F_file_type_directory_d,
+    F_file_type_fifo_d,
+    F_file_type_link_d,
+    F_file_type_regular_d,
+    F_file_type_socket_d,
+    ~S_IFMT,
+  };
+
+  const int32_t modes[] = {
+    F_file_mode_all_rwx_d,
+    F_file_mode_owner_r_d,
+    F_file_mode_owner_w_d,
+    F_file_mode_owner_x_d,
+    F_file_mode_group_r_d,
+    F_file_mode_group_w_d,
+    F_file_mode_group_x_d,
+    F_file_mode_world_r_d,
+    F_file_mode_world_w_d,
+    F_file_mode_world_x_d,
+    0,
+  };
+
+  const f_string_t params[] = {
+    "ugo+rwx",
+    "u+r",
+    "u+w",
+    "u+x",
+    "g+r",
+    "g+w",
+    "g+x",
+    "o+r",
+    "o+w",
+    "o+x",
+    "0",
+  };
+
+  {
+    uint8_t type = 0;
+    uint8_t mode = 0;
+    uint8_t param = 0;
+
+    for (type = 0; type < types_total; ++type) {
+
+      for (mode = 0; mode < modes_total; ++mode) {
+
+        for (param = 0; param < modes_total; ++param) {
+
+          const f_string_t argv[] = { "mocked_main", target.string, "-" KT_REMOVE_short_mode_s, kt_remove_mode_word_different_s.string, params[param], 0 };
+
+          struct stat stat_file;
+
+          memset(&stat_file, 0, sizeof(struct stat));
+
+          // The unknown type at the last index requires '&' logic rather than '|' logic.
+          stat_file.st_mode = types[type] == ~S_IFMT
+            ? modes[mode] & types[type]
+            : modes[mode] | types[type];
+
+          // Pre-process file.
+          will_return(__wrap_f_file_exists, F_true);
+          will_return(__wrap_f_file_is, macro_f_file_type_is_link(stat_file.st_mode));
+          will_return(__wrap_f_file_stat, &stat_file);
+          will_return(__wrap_f_file_stat, F_okay);
+
+          // Process file.
+          if (param != mode) {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+              will_return(__wrap_fl_directory_do, 1);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_after_e);
+              will_return(__wrap_f_directory_remove, F_okay);
+            }
+            else {
+              will_return(__wrap_f_file_remove, F_okay);
+            }
+          }
+          else {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+            }
+          }
+
+          const int result = kt_main_test__remove(5, argv, 0);
+
+          assert_int_equal(result, 0);
+        } // for
+      } // for
+    } // for
+  }
+}
+
+void test__kt_remove__file_mode__same_works(void **state) {
+
+  mock_unwrap = 0;
+
+  const f_string_static_t target = macro_f_string_static_t_initialize_1("to_remove", 0, 9);
+
+  const uint8_t types_total = 8;
+  const uint8_t modes_total = 10; // For both modes and params.
+
+  const int32_t types[] = {
+    F_file_type_block_d,
+    F_file_type_character_d,
+    F_file_type_directory_d,
+    F_file_type_fifo_d,
+    F_file_type_link_d,
+    F_file_type_regular_d,
+    F_file_type_socket_d,
+    ~S_IFMT,
+  };
+
+  const int32_t modes[] = {
+    F_file_mode_all_rwx_d,
+    F_file_mode_owner_r_d,
+    F_file_mode_owner_w_d,
+    F_file_mode_owner_x_d,
+    F_file_mode_group_r_d,
+    F_file_mode_group_w_d,
+    F_file_mode_group_x_d,
+    F_file_mode_world_r_d,
+    F_file_mode_world_w_d,
+    F_file_mode_world_x_d,
+    0,
+  };
+
+  const f_string_t params[] = {
+    "ugo+rwx",
+    "u+r",
+    "u+w",
+    "u+x",
+    "g+r",
+    "g+w",
+    "g+x",
+    "o+r",
+    "o+w",
+    "o+x",
+    "0",
+  };
+
+  {
+    uint8_t type = 0;
+    uint8_t mode = 0;
+    uint8_t param = 0;
+
+    for (type = 0; type < types_total; ++type) {
+
+      for (mode = 0; mode < modes_total; ++mode) {
+
+        for (param = 0; param < modes_total; ++param) {
+
+          const f_string_t argv[] = { "mocked_main", target.string, "-" KT_REMOVE_short_mode_s, kt_remove_mode_word_same_s.string, params[param], 0 };
+
+          struct stat stat_file;
+
+          memset(&stat_file, 0, sizeof(struct stat));
+
+          // The unknown type at the last index requires '&' logic rather than '|' logic.
+          stat_file.st_mode = types[type] == ~S_IFMT
+            ? modes[mode] & types[type]
+            : modes[mode] | types[type];
+
+          // Pre-process file.
+          will_return(__wrap_f_file_exists, F_true);
+          will_return(__wrap_f_file_is, macro_f_file_type_is_link(stat_file.st_mode));
+          will_return(__wrap_f_file_stat, &stat_file);
+          will_return(__wrap_f_file_stat, F_okay);
+
+          // Process file.
+          if (param == mode) {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+              will_return(__wrap_fl_directory_do, 1);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_after_e);
+              will_return(__wrap_f_directory_remove, F_okay);
+            }
+            else {
+              will_return(__wrap_f_file_remove, F_okay);
+            }
+          }
+          else {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+            }
+          }
+
+          const int result = kt_main_test__remove(5, argv, 0);
+
+          assert_int_equal(result, 0);
+        } // for
+      } // for
+    } // for
+  }
+}
+
+void test__kt_remove__file_mode__similar_works(void **state) {
+
+  mock_unwrap = 0;
+
+  const f_string_static_t target = macro_f_string_static_t_initialize_1("to_remove", 0, 9);
+
+  const uint8_t types_total = 8;
+  const uint8_t modes_total = 10; // For both modes and params.
+
+  const int32_t types[] = {
+    F_file_type_block_d,
+    F_file_type_character_d,
+    F_file_type_directory_d,
+    F_file_type_fifo_d,
+    F_file_type_link_d,
+    F_file_type_regular_d,
+    F_file_type_socket_d,
+    ~S_IFMT,
+  };
+
+  const int32_t modes[] = {
+    F_file_mode_all_rwx_d,
+    F_file_mode_owner_r_d,
+    F_file_mode_owner_w_d,
+    F_file_mode_owner_x_d,
+    F_file_mode_group_r_d,
+    F_file_mode_group_w_d,
+    F_file_mode_group_x_d,
+    F_file_mode_world_r_d,
+    F_file_mode_world_w_d,
+    F_file_mode_world_x_d,
+    0,
+  };
+
+  const f_string_t params[] = {
+    "ugo+rwx",
+    "u+r",
+    "u+w",
+    "u+x",
+    "g+r",
+    "g+w",
+    "g+x",
+    "o+r",
+    "o+w",
+    "o+x",
+    "0",
+  };
+
+  {
+    uint8_t type = 0;
+    uint8_t mode = 0;
+    uint8_t param = 0;
+
+    for (type = 0; type < types_total; ++type) {
+
+      for (mode = 0; mode < modes_total; ++mode) {
+
+        for (param = 0; param < modes_total; ++param) {
+
+          const f_string_t argv[] = { "mocked_main", target.string, "-" KT_REMOVE_short_mode_s, kt_remove_mode_word_similar_s.string, params[param], 0 };
+
+          struct stat stat_file;
+
+          memset(&stat_file, 0, sizeof(struct stat));
+
+          // The unknown type at the last index requires '&' logic rather than '|' logic.
+          stat_file.st_mode = types[type] == ~S_IFMT
+            ? modes[mode] & types[type]
+            : modes[mode] | types[type];
+
+          // Pre-process file.
+          will_return(__wrap_f_file_exists, F_true);
+          will_return(__wrap_f_file_is, macro_f_file_type_is_link(stat_file.st_mode));
+          will_return(__wrap_f_file_stat, &stat_file);
+          will_return(__wrap_f_file_stat, F_okay);
+
+          // Process file.
+          if (modes[param] & modes[mode]) {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+              will_return(__wrap_fl_directory_do, 1);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_after_e);
+              will_return(__wrap_f_directory_remove, F_okay);
+            }
+            else {
+              will_return(__wrap_f_file_remove, F_okay);
+            }
+          }
+          else {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+            }
+          }
+
+          const int result = kt_main_test__remove(5, argv, 0);
+
+          assert_int_equal(result, 0);
+        } // for
+      } // for
+    } // for
+  }
+}
+
+void test__kt_remove__file_mode__not_works(void **state) {
+
+  mock_unwrap = 0;
+
+  const f_string_static_t target = macro_f_string_static_t_initialize_1("to_remove", 0, 9);
+
+  const uint8_t types_total = 8;
+  const uint8_t modes_total = 10; // For both modes and params.
+
+  const int32_t types[] = {
+    F_file_type_block_d,
+    F_file_type_character_d,
+    F_file_type_directory_d,
+    F_file_type_fifo_d,
+    F_file_type_link_d,
+    F_file_type_regular_d,
+    F_file_type_socket_d,
+    ~S_IFMT,
+  };
+
+  const int32_t modes[] = {
+    F_file_mode_all_rwx_d,
+    F_file_mode_owner_r_d,
+    F_file_mode_owner_w_d,
+    F_file_mode_owner_x_d,
+    F_file_mode_group_r_d,
+    F_file_mode_group_w_d,
+    F_file_mode_group_x_d,
+    F_file_mode_world_r_d,
+    F_file_mode_world_w_d,
+    F_file_mode_world_x_d,
+    0,
+  };
+
+  const f_string_t params[] = {
+    "ugo+rwx",
+    "u+r",
+    "u+w",
+    "u+x",
+    "g+r",
+    "g+w",
+    "g+x",
+    "o+r",
+    "o+w",
+    "o+x",
+    "0",
+  };
+
+  {
+    uint8_t type = 0;
+    uint8_t mode = 0;
+    uint8_t param = 0;
+
+    for (type = 0; type < types_total; ++type) {
+
+      for (mode = 0; mode < modes_total; ++mode) {
+
+        for (param = 0; param < modes_total; ++param) {
+
+          const f_string_t argv[] = { "mocked_main", target.string, "-" KT_REMOVE_short_mode_s, kt_remove_mode_word_not_s.string, params[param], 0 };
+
+          struct stat stat_file;
+
+          memset(&stat_file, 0, sizeof(struct stat));
+
+          // The unknown type at the last index requires '&' logic rather than '|' logic.
+          stat_file.st_mode = types[type] == ~S_IFMT
+            ? modes[mode] & types[type]
+            : modes[mode] | types[type];
+
+          // Pre-process file.
+          will_return(__wrap_f_file_exists, F_true);
+          will_return(__wrap_f_file_is, macro_f_file_type_is_link(stat_file.st_mode));
+          will_return(__wrap_f_file_stat, &stat_file);
+          will_return(__wrap_f_file_stat, F_okay);
+
+          // Process file.
+          if (modes[param] != modes[mode]) {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+              will_return(__wrap_fl_directory_do, 1);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, &target);
+              will_return(__wrap_fl_directory_do, f_directory_recurse_do_flag_action_e | f_directory_recurse_do_flag_directory_e | f_directory_recurse_do_flag_top_after_e);
+              will_return(__wrap_f_directory_remove, F_okay);
+            }
+            else {
+              will_return(__wrap_f_file_remove, F_okay);
+            }
+          }
+          else {
+            if (macro_f_file_type_is_directory(stat_file.st_mode)) {
+              will_return(__wrap_f_directory_empty, F_true);
+            }
+          }
+
+          const int result = kt_main_test__remove(5, argv, 0);
+
+          assert_int_equal(result, 0);
+        } // for
+      } // for
+    } // for
+  }
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

diff --git a/tests/unit/remove/c/test-remove-file_mode.h b/tests/unit/remove/c/test-remove-file_mode.h
new file mode 100644 (file)
index 0000000..e3d936d
--- /dev/null
+++ b/tests/unit/remove/c/test-remove-file_mode.h
@@ -0,0 +1,33 @@
+/**
+ * Kevux Tools - Remove
+ *
+ * Project: Kevux Tools
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the remove.
+ */
+#ifndef _TEST__KT_remove__file_mode
+#define _TEST__KT_remove__file_mode
+
+/**
+ * Test that the remove removes or doesn't remove based on file mode being different.
+ */
+extern void test__kt_remove__file_mode__different_works(void **state);
+
+/**
+ * Test that the remove removes or doesn't remove based on file mode being the same.
+ */
+extern void test__kt_remove__file_mode__same_works(void **state);
+
+/**
+ * Test that the remove removes or doesn't remove based on file mode being similar.
+ */
+extern void test__kt_remove__file_mode__similar_works(void **state);
+
+/**
+ * Test that the remove removes or doesn't remove based on file mode being not the same.
+ */
+extern void test__kt_remove__file_mode__not_works(void **state);
+
+#endif // _TEST__KT_remove__file_mode

diff --git a/tests/unit/remove/c/test-remove-file_type.c b/tests/unit/remove/c/test-remove-file_type.c
index 0ac15a1346bd851a761f916d913fc691e3060580..a1748d589916c1cce3f89263cc58f63673ac9a4b 100644 (file)
--- a/tests/unit/remove/c/test-remove-file_type.c
+++ b/tests/unit/remove/c/test-remove-file_type.c
@@ -78,7 +78,7 @@ void test__kt_remove__file_type__works(void **state) {
         const int result = kt_main_test__remove(3, argv, 0);
 
         assert_int_equal(result, 0);
-      }
+      } // for
     } // for
   }
 }

diff --git a/tests/unit/remove/c/test-remove.c b/tests/unit/remove/c/test-remove.c
index a89106dce6a2a1925e9277967c9f0b4ac12bd4fd..59a276c5f5c2599b46273119cd766252b987f816 100644 (file)
--- a/tests/unit/remove/c/test-remove.c
+++ b/tests/unit/remove/c/test-remove.c
@@ -43,6 +43,11 @@ int main(void) {
     cmocka_unit_test(test__kt_remove__directory_tree_simple__one_child_none_parent_two_exists_link),
     cmocka_unit_test(test__kt_remove__directory_tree_simple__one_child_none_parent_two_exists_link_not),
 
+    cmocka_unit_test(test__kt_remove__file_mode__different_works),
+    cmocka_unit_test(test__kt_remove__file_mode__same_works),
+    cmocka_unit_test(test__kt_remove__file_mode__similar_works),
+    cmocka_unit_test(test__kt_remove__file_mode__not_works),
+
     cmocka_unit_test(test__kt_remove__file_type__works),
 
     cmocka_unit_test(test__kt_remove__group__name_works),

diff --git a/tests/unit/remove/c/test-remove.h b/tests/unit/remove/c/test-remove.h
index d24851a4e8571812c6e884ea7504ea0d233aa7d4..acdcb3f210cda4c1f891b6e566928d437fad91a1 100644 (file)
--- a/tests/unit/remove/c/test-remove.h
+++ b/tests/unit/remove/c/test-remove.h
@@ -33,6 +33,7 @@
 #include "test-remove-directory_no_args.h"
 #include "test-remove-directory_recurse_simple.h"
 #include "test-remove-directory_tree_simple.h"
+#include "test-remove-file_mode.h"
 #include "test-remove-file_type.h"
 #include "test-remove-group.h"
 #include "test-remove-print_help.h"