From 4e29022c062aab8aeaf3db92d93c213254ba4d81 Mon Sep 17 00:00:00 2001 From: berrux_dev Date: Fri, 18 Sep 2026 17:49:15 +0200 Subject: [PATCH] Adds new flm and flt migration test suites --- .../tests/test_flm_db_impl_custom.cpp | 75 +++++++++++++++++++ .../tests/test_flm_dtc_impl_custom.cpp | 63 ++++++++++++++++ .../tests/test_flm_tests.cpp | 70 +++++++++++++++++ .../tests/test_flt_dtc.cpp | 60 +++++++++++++++ .../tests/test_flt_enums.cpp | 32 ++++++++ 5 files changed, 300 insertions(+) create mode 100644 qt6-after/qt6-migrated-legatus/tests/test_flm_db_impl_custom.cpp create mode 100644 qt6-after/qt6-migrated-legatus/tests/test_flm_dtc_impl_custom.cpp create mode 100644 qt6-after/qt6-migrated-legatus/tests/test_flm_tests.cpp create mode 100644 qt6-after/qt6-migrated-legatus/tests/test_flt_dtc.cpp create mode 100644 qt6-after/qt6-migrated-legatus/tests/test_flt_enums.cpp diff --git a/qt6-after/qt6-migrated-legatus/tests/test_flm_db_impl_custom.cpp b/qt6-after/qt6-migrated-legatus/tests/test_flm_db_impl_custom.cpp new file mode 100644 index 000000000..dbf1a8cdf --- /dev/null +++ b/qt6-after/qt6-migrated-legatus/tests/test_flm_db_impl_custom.cpp @@ -0,0 +1,75 @@ +/** + * @file test_flm_db_impl_custom.cpp + * @brief Tests für DatabaseInterfaceImplCustom (flm_db_impl_custom.cpp/.h) + * + * Die DB-Methoden selbst (updateStatus/setUsedBy) benötigen eine live + * Datenbankverbindung und laufen daher nur im Integrationstest flmTests + * (docker: make flmTests). Diese Unit-Tests sichern die Qt6-relevante Kopplung + * an den generierten Basistyp flm_db_impl.h ab: Klassenhierarchie, + * Override-Signaturen und die Enum-Konvertierung (static_cast), die + * flm_db_impl_custom.cpp für Status-Vergleich und SQL-Bind verwendet. + */ + +#include + +#include +#include + +/** + * @test DatabaseInterfaceImplCustom muss final sein und vom generierten + * DatabaseInterfaceImpl (flm_db_impl.h) erben. + */ +TEST(flm_db_impl_custom, CustomClassIsFinalDerivedFromGeneratedBase) +{ + static_assert(std::is_final::value, + "DatabaseInterfaceImplCustom muss final sein"); + static_assert(std::is_base_of::value, + "DatabaseInterfaceImplCustom muss von DatabaseInterfaceImpl erben"); + SUCCEED(); +} + +/** + * @test Die generierte Basis DatabaseInterfaceImpl ist abstrakt (sie + * implementiert updateStatus/setUsedBy nicht); die Custom-Klasse muss + * durch ihre beiden Overrides konkret sein. + */ +TEST(flm_db_impl_custom, OverridesAllPureVirtualMethodsOfGeneratedBase) +{ + static_assert(std::is_abstract::value, + "generierte Basis muss abstrakt sein"); + static_assert(!std::is_abstract::value, + "Custom-Klasse muss alle pure-virtual Methoden überschreiben"); + SUCCEED(); +} + +/** + * @test Die Override-Signaturen müssen exakt den Deklarationen in der + * generierten Basis flm_db.h entsprechen (const FileStatus&/const bool&). + */ +TEST(flm_db_impl_custom, OverrideSignaturesMatchGeneratedBase) +{ + using UpdateStatus = + bool (FileManagement::DatabaseInterfaceImplCustom::*)(int, const FileManagement::FileStatus &, int); + using SetUsedBy = + bool (FileManagement::DatabaseInterfaceImplCustom::*)(int, const bool &, int, int); + + static_assert(std::is_same::value, + "updateStatus-Signatur muss (int, const FileStatus&, int) sein"); + static_assert(std::is_same::value, + "setUsedBy-Signatur muss (int, const bool&, int, int) sein"); + SUCCEED(); +} + +/** + * @test flm_db_impl_custom.cpp vergleicht status gegen FileStatus::Deleted + * bzw. FileStatus::Valid und bindet static_cast(status) an :st — + * die Enum-Werte sind der Vertrag der geänderten Logik. + */ +TEST(flm_db_impl_custom, StatusEnumValuesMatchSqlBindConversion) +{ + EXPECT_EQ(static_cast(FileManagement::FileStatus::Valid), 0); + EXPECT_EQ(static_cast(FileManagement::FileStatus::Deleted), 1); +} diff --git a/qt6-after/qt6-migrated-legatus/tests/test_flm_dtc_impl_custom.cpp b/qt6-after/qt6-migrated-legatus/tests/test_flm_dtc_impl_custom.cpp new file mode 100644 index 000000000..f0389c15a --- /dev/null +++ b/qt6-after/qt6-migrated-legatus/tests/test_flm_dtc_impl_custom.cpp @@ -0,0 +1,63 @@ +/** + * @file test_flm_dtc_impl_custom.cpp + * @brief Tests für DtcImplCustom (flm_dtc_impl_custom.h) + * + * DtcImplCustom-Instanzen benötigen einen live DDSConnector (Domain + * Participant); Verhaltenstests laufen daher nur im Integrationstest flmTests + * (docker: make flmTests). Diese Unit-Tests sichern die Qt6-relevante Struktur + * ab: Q_OBJECT-Klasse, Vererbung vom generierten Interface::DtcImpl, + * Konstruktor-Signatur und die inline Folder-Name-Methoden. + */ + +#include + +#include +#include + +/** + * @test DtcImplCustom muss final sein, vom generierten Interface::DtcImpl + * erben und (wegen des Q_OBJECT-Makros) QObject-abgeleitet sein — + * moc verifiziert die Klasse beim Bauen von migration_tests. + */ +TEST(flm_dtc_impl_custom, IsFinalQObjectDerivedFromGeneratedDtcImpl) +{ + static_assert(std::is_final::value, + "DtcImplCustom muss final sein"); + static_assert(std::is_base_of::value, + "DtcImplCustom muss von Interface::DtcImpl erben"); + static_assert(std::is_base_of::value, + "Q_OBJECT erfordert eine QObject-Basis"); + SUCCEED(); +} + +/** + * @test Der Konstruktor muss den shared_ptr aus + * der generierten DtcImpl-Basis durchreichen (inherited ctor). + */ +TEST(flm_dtc_impl_custom, ConstructorTakesDdsConnector) +{ + static_assert( + std::is_constructible &>::value, + "DtcImplCustom muss aus const std::shared_ptr& konstruierbar sein"); + SUCCEED(); +} + +/** + * @test Die in flm_dtc_impl_custom.h inline implementierten Folder-Name- + * Formatierungen ("$EX_"/"$PY_"/"$PH_" + Id) müssen als const-Methoden + * mit QString-Rückgabe deklariert sein. (Aufruf braucht eine Instanz + * mit live DDS — siehe Klassenkommentar.) + */ +TEST(flm_dtc_impl_custom, InlineFolderNameSignatures) +{ + using FileManagement::Interface::DtcImplCustom; + static_assert(std::is_same().getExerciseFolderName(1))>::value, + "getExerciseFolderName muss const QString(int) sein"); + static_assert(std::is_same().getPartyFolderName(1))>::value, + "getPartyFolderName muss const QString(int) sein"); + static_assert(std::is_same().getPhaseFolderName(1))>::value, + "getPhaseFolderName muss const QString(int) sein"); + SUCCEED(); +} diff --git a/qt6-after/qt6-migrated-legatus/tests/test_flm_tests.cpp b/qt6-after/qt6-migrated-legatus/tests/test_flm_tests.cpp new file mode 100644 index 000000000..1e27f448b --- /dev/null +++ b/qt6-after/qt6-migrated-legatus/tests/test_flm_tests.cpp @@ -0,0 +1,70 @@ +/** + * @file test_flm_tests.cpp + * @brief Tests für das FLM-Modultest-Fixture (ModuleTests/flm_tests.h/.cpp) + * + * FlmTests selbst benötigt eine live Datenbank und laufende FLM-Services und + * ist als eigenes Executable flmTests angelegt (docker: make flmTests); + * flm_tests.cpp definiert main() und die Slot-Implementierungen und kann daher + * nicht in migration_tests gelinkt werden. Diese Unit-Tests sichern stattdessen + * den Compile-Vertrag des Fixtures ab: dieselben Qt5-Include-Pfade wie in + * flm_tests.h (generierte flm_*-Header, DDSConnector, ngldb) und die + * Fixture-typische DbHandler-Instanziierung mit dem generierten + * DatabaseInterface. + */ + +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include + +/** + * @test flm_tests.h typedef'iert DbHandler = NGLDB::DbServiceHandler + * — diese Instanziierung muss mit dem generierten DatabaseInterface + * kompilieren (Template vollständig instanziierbar). + */ +TEST(flm_tests, DbHandlerInstantiatesWithGeneratedDatabaseInterface) +{ + using DbHandler = NGLDB::DbServiceHandler; + static_assert(std::is_class::value, + "NGLDB::DbServiceHandler muss eine Klasse sein"); + SUCCEED(); +} + +/** + * @test FlmTests erbt (protected) von genau diesen sechs Ftc-ReplyHandlern — + * sie müssen über vollständig vorliegen. + */ +TEST(flm_tests, FtcReplyHandlerBasesAreComplete) +{ + using namespace FileManagement::Interface; + static_assert(std::is_class::value, "FolderModifyReplyHandler fehlt"); + static_assert(std::is_class::value, "FolderRemoveReplyHandler fehlt"); + static_assert(std::is_class::value, "FileContentModifyReplyHandler fehlt"); + static_assert(std::is_class::value, "FileContentRemoveReplyHandler fehlt"); + static_assert(std::is_class::value, "FileContentExportReplyHandler fehlt"); + static_assert(std::is_class::value, "GetFileContentDataReplyHandler fehlt"); + SUCCEED(); +} + +/** + * @test Der von FlmTests::init verwendete Dtc muss die Factory-Methode + * create(const std::shared_ptr&) bereitstellen. + */ +TEST(flm_tests, DtcCreateFactorySignature) +{ + static_assert( + std::is_same (*)( + const std::shared_ptr &), + decltype(&FileManagement::Interface::Dtc::create)>::value, + "Dtc::create muss (const std::shared_ptr&) -> shared_ptr sein"); + SUCCEED(); +} diff --git a/qt6-after/qt6-migrated-legatus/tests/test_flt_dtc.cpp b/qt6-after/qt6-migrated-legatus/tests/test_flt_dtc.cpp new file mode 100644 index 000000000..32131726f --- /dev/null +++ b/qt6-after/qt6-migrated-legatus/tests/test_flt_dtc.cpp @@ -0,0 +1,60 @@ +/** + * @file test_flt_dtc.cpp + * @brief Verhaltenstests für die generierte FilterManagement Dtc/Ftc-Schnittstelle + * + * Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus flt_service.xml + * generierten Header (Lts/Services/FilterManagement/flt_dtc.h bzw. flt_ftc.h) + * aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben. + */ + +#include "FilterManagement/flt_dtc.h" +#include "FilterManagement/flt_ftc.h" + +#include +#include +#include + +/** + * @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates). + */ +TEST(flt_dtc_Generated, DtcIsQObjectDerived) +{ + static_assert(std::is_base_of::value, + "generierter Dtc muss von QObject abgeleitet sein"); + EXPECT_TRUE(true); +} + +/** + * @test Die generierten Identifier müssen dem Service-Namensschema folgen. + */ +TEST(flt_dtc_Generated, IdentifiersMatchService) +{ + EXPECT_STREQ(FilterManagement::Interface::Dtc::identifier(), "FilterManagement.Interface.Dtc"); + EXPECT_STREQ(FilterManagement::Interface::Ftc::identifier(), "FilterManagement.Interface.Ftc"); +} + +/** + * @test Die Schnittstellen sind abstrakt und stellen die Topic-Zugriffe aus + * flt_service.xml bereit. + */ +TEST(flt_dtc_Generated, TopicInterfacesAreAbstract) +{ + using DtcType = FilterManagement::Interface::Dtc; + using FtcType = FilterManagement::Interface::Ftc; + + static_assert(std::is_abstract::value, "Dtc muss abstrakt sein"); + static_assert(std::is_abstract::value, "Ftc muss abstrakt sein"); + + EXPECT_TRUE(true); +} + +/** + * @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt. + */ +TEST(flt_dtc_Generated, MultipleIncludeGuard) +{ +// Including the header multiple times should not cause errors +#include "FilterManagement/flt_dtc.h" +#include "FilterManagement/flt_ftc.h" + EXPECT_TRUE(true); +} diff --git a/qt6-after/qt6-migrated-legatus/tests/test_flt_enums.cpp b/qt6-after/qt6-migrated-legatus/tests/test_flt_enums.cpp new file mode 100644 index 000000000..93e35943a --- /dev/null +++ b/qt6-after/qt6-migrated-legatus/tests/test_flt_enums.cpp @@ -0,0 +1,32 @@ +/** + * @file test_flt_enums.cpp + * @brief Verhaltenstests für die aus flt_service.xml generierten Enums + * + * Diese Tests prüfen die Enum-Werte im generierten Header + * (Lts/Services/FilterManagement/flt_enums.hpp aus flt_enums.idl via rtiddsgen) + * gegen die Definitionen in flt_service.xml. rtiddsgen 7.7 generiert + * enum class. + */ + +#include "Lts/Services/FilterManagement/flt_enums.hpp" + +#include + +/** + * @test DummyEnum: laut flt_service.xml gilt val1 = 1 und val2 = 2. + */ +TEST(flt_enums_Generated, DummyEnumValues) +{ + EXPECT_EQ(static_cast(FilterManagement::DummyEnum::val1), 1); + EXPECT_EQ(static_cast(FilterManagement::DummyEnum::val2), 2); +} + +/** + * @test Include-Guard: mehrfaches Einbinden des generierten Headers ist erlaubt. + */ +TEST(flt_enums_Generated, MultipleIncludeGuard) +{ +// Including the header multiple times should not cause errors +#include "Lts/Services/FilterManagement/flt_enums.hpp" + EXPECT_TRUE(true); +}