test: add leistungflags_test and CountAction tests

Add Catch2 test for LeistungFlags and CountAction unit tests.
Register leistungflags_test in CMakeLists.txt.

Co-authored-by: CommandCodeBot <noreply@commandcode.ai>

CMakeLists.txt

@@ -105,7 +105,7 @@ if(BUILD_HOSTRW)
         ${RW_SRC}/util/msgetopt.cpp
         ${RW_SRC}/rest/PraxisVerbundLock.cpp
     )
-    target_compile_definitions(rw_host PRIVATE KVAI_HOSTRW)
+    target_compile_definitions(rw_host PRIVATE KVAI_HOSTRW RW_DLL)
     target_link_libraries(rw_host PRIVATE rw_core)
 endif()
 
@@ -148,6 +148,11 @@ if(BUILD_TESTS)
     target_link_libraries(bitset_catch_test PRIVATE rw_core)
     add_test(NAME bitset_catch_test COMMAND bitset_catch_test)
 
+    add_executable(leistungflags_test tests/leistungflags_test.cpp)
+    target_include_directories(leistungflags_test PRIVATE ${CATCH2_INCLUDE_DIR})
+    target_link_libraries(leistungflags_test PRIVATE rw_core)
+    add_test(NAME leistungflags_test COMMAND leistungflags_test)
+
     add_executable(predicates_test tests/predicates_test.cpp)
     target_include_directories(predicates_test PRIVATE ${CATCH2_INCLUDE_DIR} tests)
     target_link_libraries(predicates_test PRIVATE rw_core)

tests/actions_test.cpp

@@ -9,6 +9,7 @@
 
 #include "rw_actions/str_to_int.hpp"
 #include "rw_actions/datum_selektor.hpp"
+#include "rw_actions/count_action.hpp"
 
 using namespace maatini::rw;
 
@@ -60,3 +61,43 @@ TEST_CASE("DatumSelektor: kein Datum", "[actions]") {
     REQUIRE(result != nullptr);
     REQUIRE(std::string(result) == "");
 }
+
+// =============================================================================
+// CountAction — zählt Aufrufe
+// =============================================================================
+
+TEST_CASE("CountAction: zaehlt Inkrement", "[actions]") {
+    int counter = 0;
+    CountAction a(counter, 1);
+    MockLeistung l;
+    a(&l);
+    REQUIRE(counter == 1);
+    REQUIRE(a.value() == 1);
+}
+
+TEST_CASE("CountAction: mehrfacher Aufruf", "[actions]") {
+    int counter = 0;
+    CountAction a(counter, 3);
+    MockLeistung l;
+    a(&l);
+    a(&l);
+    a(&l);
+    REQUIRE(counter == 9);
+    REQUIRE(a.value() == 9);
+}
+
+TEST_CASE("CountAction: negativer Inkrement", "[actions]") {
+    int counter = 10;
+    CountAction a(counter, -2);
+    MockLeistung l;
+    a(&l);
+    REQUIRE(counter == 8);
+}
+
+TEST_CASE("CountAction: null Inkrement aendert nichts", "[actions]") {
+    int counter = 5;
+    CountAction a(counter, 0);
+    MockLeistung l;
+    a(&l);
+    REQUIRE(counter == 5);
+}

tests/leistungflags_test.cpp

@@ -0,0 +1,200 @@
+//*****************************************************************************
+//  Autor   : CodeWhale
+//  Inhalt  : LeistungFlags-Tests (enum class Flag — Phasen 2+4 Absicherung)
+//*****************************************************************************
+
+#define CATCH_CONFIG_MAIN
+#include "catch2/catch_amalgamated.hpp"
+#include "goae/leistungflags.hpp"
+#include "rest/rw_konstanten.hpp"
+
+using namespace maatini::rw;
+
+// Minimales char-Array als Flags-Backend (simuliert Leistung::flags_)
+static char test_flags[sizes::LST_FLAGS];
+
+// Hilfsfunktion: frisches Flags-Array
+static void reset_flags() {
+    std::memset(test_flags, '0', sizeof(test_flags));
+}
+
+// =============================================================================
+// Initialisierung
+// =============================================================================
+
+TEST_CASE("LeistungFlags: initial clear setzt alle auf '0'", "[leistungflags]") {
+    reset_flags();
+    // Mit 'X' vorbefüllen, damit clear() sichtbar wird
+    std::memset(test_flags, 'X', sizeof(test_flags));
+    LeistungFlags flags(test_flags);
+    flags.clear();
+    for (size_t i = 0; i < sizes::LST_FLAGS; ++i) {
+        REQUIRE(test_flags[i] == '0');
+    }
+}
+
+// =============================================================================
+// set() — einzelne Flags setzen
+// =============================================================================
+
+TEST_CASE("LeistungFlags: set(unsichtbar)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::unsichtbar);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::plausibel));
+}
+
+TEST_CASE("LeistungFlags: set(plausibel)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::plausibel);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::plausibel));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+}
+
+TEST_CASE("LeistungFlags: set(hochbewertet)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::hochbewertet);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::hochbewertet));
+}
+
+TEST_CASE("LeistungFlags: set(loeschend_wirksam)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::loeschend_wirksam);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam));
+}
+
+TEST_CASE("LeistungFlags: set(hinweis)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::hinweis);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::hinweis));
+}
+
+TEST_CASE("LeistungFlags: set(hinweis_umwandeln)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::hinweis_umwandeln);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::hinweis_umwandeln));
+}
+
+// =============================================================================
+// Additive Flags (hochbewertet + loeschend_wirksam = loeschend_wirksam_hochbewertet)
+// =============================================================================
+
+TEST_CASE("LeistungFlags: hochbewertet + loeschend_wirksam = kombiniert", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::hochbewertet);
+    flags.set(LeistungFlags::Flag::loeschend_wirksam);
+    // Kombiniertes Flag ersetzt die Einzelflags
+    REQUIRE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam_hochbewertet));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::hochbewertet));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam));
+}
+
+TEST_CASE("LeistungFlags: loeschend_wirksam + hochbewertet = kombiniert (Reihenfolge egal)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::loeschend_wirksam);
+    flags.set(LeistungFlags::Flag::hochbewertet);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam_hochbewertet));
+}
+
+// =============================================================================
+// clear() — einzelnes Flag zurücksetzen
+// =============================================================================
+
+TEST_CASE("LeistungFlags: clear(einzelnes Flag)", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::unsichtbar);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+    flags.clear(LeistungFlags::Flag::unsichtbar);
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+}
+
+TEST_CASE("LeistungFlags: clear(loeschend_wirksam) aus kombiniertem Flag", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::hochbewertet);
+    flags.set(LeistungFlags::Flag::loeschend_wirksam);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam_hochbewertet));
+
+    flags.clear(LeistungFlags::Flag::loeschend_wirksam);
+    // Sollte nur noch hochbewertet sein
+    REQUIRE(flags.is_set(LeistungFlags::Flag::hochbewertet));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam_hochbewertet));
+}
+
+// =============================================================================
+// clear_group() — gesamte Gruppe zurücksetzen
+// =============================================================================
+
+TEST_CASE("LeistungFlags: clear_group setzt Gruppe zurück", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::hochbewertet);
+    flags.set(LeistungFlags::Flag::loeschend_wirksam);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam_hochbewertet));
+
+    flags.clear_group(LeistungFlags::Flag::hochbewertet);
+    // Gruppe 3 komplett gelöscht
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::hochbewertet));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam));
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::loeschend_wirksam_hochbewertet));
+}
+
+// =============================================================================
+// set_conditional()
+// =============================================================================
+
+TEST_CASE("LeistungFlags: set_conditional mit true", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set_conditional(LeistungFlags::Flag::unsichtbar, true);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+}
+
+TEST_CASE("LeistungFlags: set_conditional mit false", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::unsichtbar);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+    flags.set_conditional(LeistungFlags::Flag::unsichtbar, false);
+    REQUIRE_FALSE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+}
+
+// =============================================================================
+// Vergangenheitsfrequenz (Gruppe 1)
+// =============================================================================
+
+TEST_CASE("LeistungFlags: vergangenheit_p und vergangenheit_pt schliessen sich aus", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::vergangenheit_p);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::vergangenheit_p));
+
+    flags.set(LeistungFlags::Flag::vergangenheit_pt);
+    // vergangenheit_pt ersetzt vergangenheit_p (gleiche Gruppe)
+    REQUIRE(flags.is_set(LeistungFlags::Flag::vergangenheit_pt));
+}
+
+// =============================================================================
+// unsichtbar + plausibel — unsichtbar gewinnt
+// =============================================================================
+
+TEST_CASE("LeistungFlags: unsichtbar ueberschreibt plausibel", "[leistungflags]") {
+    reset_flags();
+    LeistungFlags flags(test_flags);
+    flags.set(LeistungFlags::Flag::plausibel);
+    REQUIRE(flags.is_set(LeistungFlags::Flag::plausibel));
+
+    flags.set(LeistungFlags::Flag::unsichtbar);
+    // unsichtbar: Gruppe 0, überschreibt plausibel
+    REQUIRE(flags.is_set(LeistungFlags::Flag::unsichtbar));
+}