Adapts shared tests and common code to generated rtiddsgen API

Updates test suites and Lts/Common consumers to plain member access.

qt6-after/qt6-migrated-legatus/tests/test_ism_dtc.cpp

@@ -1,16 +1,92 @@
 /**
  * @file test_ism_dtc.cpp
- * @brief Compilation test for include/InfrastructureManagement/ism_dtc.h
+ * @brief Verhaltenstests für die generierte InfrastructureManagement Dtc/Ftc-Schnittstelle
  *
- * This test verifies that the migrated header compiles correctly with Qt6/C++23.
+ * Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus ism_service.xml
+ * generierten Header (Lts/Services/InfrastructureManagement/ism_dtc.h bzw.
+ * ism_ftc.h) aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben.
+ * Zusätzlich werden die plainen DDS-Typ-Member aus ism.hpp verifiziert, auf die
+ * der migrierte Code (object_main_structure_element.cpp) zugreift.
  */
 
-#include "include/InfrastructureManagement/ism_dtc.h"
+#include "InfrastructureManagement/ism_dtc.h"
+#include "InfrastructureManagement/ism_ftc.h"
 
 #include <gtest/gtest.h>
+#include <QObject>
+#include <type_traits>
 
-TEST(ism_dtc_Compilation, HeaderCompiles)
+/**
+ * @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates);
+ *       beide Schnittstellen sind abstrakt.
+ */
+TEST(ism_dtc_Generated, DtcIsQObjectDerived)
 {
-    // This test verifies that the header compiles without errors
+    static_assert(std::is_base_of<QObject, InfrastructureManagement::Interface::Dtc>::value,
+                  "generierter Dtc muss von QObject abgeleitet sein");
+    static_assert(std::is_abstract<InfrastructureManagement::Interface::Dtc>::value,
+                  "Dtc muss abstrakt sein");
+    static_assert(std::is_abstract<InfrastructureManagement::Interface::Ftc>::value,
+                  "Ftc muss abstrakt sein");
+    EXPECT_TRUE(true);
+}
+
+/**
+ * @test Die generierten Identifier müssen dem Service-Namensschema folgen.
+ */
+TEST(ism_dtc_Generated, IdentifiersMatchService)
+{
+    EXPECT_STREQ(InfrastructureManagement::Interface::Dtc::identifier(), "InfrastructureManagement.Interface.Dtc");
+    EXPECT_STREQ(InfrastructureManagement::Interface::Ftc::identifier(), "InfrastructureManagement.Interface.Ftc");
+}
+
+/**
+ * @test Die DDS-Typen aus ism.hpp müssen plain-Member bereitstellen (rtiddsgen 7.7):
+ *       MainStructureElement (geoPosition, elements) und StructureElement (path),
+ *       die object_main_structure_element.cpp direkt als Felder nutzt.
+ */
+TEST(ism_dtc_Generated, StructureElementsHavePlainMembers)
+{
+    using MainStructureElement = InfrastructureManagement::MainStructureElement;
+    using StructureElement = InfrastructureManagement::StructureElement;
+
+    static_assert(std::is_base_of<::Core::BaseEntity, MainStructureElement>::value,
+                  "MainStructureElement muss von Core::BaseEntity abgeleitet sein (id/name/isUsed)");
+    static_assert(std::is_same<decltype(MainStructureElement{}.structureElementId), int32_t>::value,
+                  "structureElementId muss ein plain int32_t-Member sein");
+    static_assert(std::is_same<decltype(MainStructureElement{}.geoPosition), ::Core::GeoPosition>::value,
+                  "geoPosition muss ein plain Core::GeoPosition-Member sein");
+    static_assert(std::is_same<decltype(MainStructureElement{}.elements),
+                               ::omg::types::sequence<::InfrastructureManagement::StructureElement>>::value,
+                  "elements muss eine omg::types::sequence<StructureElement> sein");
+
+    static_assert(std::is_same<decltype(StructureElement{}.structureElementTypeId),
+                               ::InfrastructureManagement::StructureElementType>::value,
+                  "structureElementTypeId muss ein plain StructureElementType-Member sein");
+    static_assert(std::is_same<decltype(StructureElement{}.path), ::omg::types::sequence<int32_t>>::value,
+                  "path muss eine omg::types::sequence<int32_t> sein");
+
+    // Core::GeoPosition bringt plain lon/lat/z-Member mit (kein Getter/Setter mehr).
+    static_assert(std::is_same<decltype(::Core::GeoPosition{}.lon), double>::value,
+                  "GeoPosition::lon muss ein plain double-Member sein");
+    static_assert(std::is_same<decltype(::Core::GeoPosition{}.lat), double>::value,
+                  "GeoPosition::lat muss ein plain double-Member sein");
+    static_assert(std::is_same<decltype(::Core::GeoPosition{}.z), double>::value,
+                  "GeoPosition::z muss ein plain double-Member sein");
+
+    static_assert(std::is_enum<::InfrastructureManagement::StructureElementType>::value,
+                  "StructureElementType muss aus ism_enums.hpp als Aufzählung vorliegen");
+
+    EXPECT_TRUE(true);
+}
+
+/**
+ * @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
+ */
+TEST(ism_dtc_Generated, MultipleIncludeGuard)
+{
+// Including the header multiple times should not cause errors
+#include "InfrastructureManagement/ism_dtc.h"
+#include "InfrastructureManagement/ism_ftc.h"
     EXPECT_TRUE(true);
 }