Remove tests not built by the release build and scope new_docker_build.sh to the release branch

- Delete all test_*.cpp, *.cmake helpers, MockCoordTrans.h and the gtest/strix
  tooling from tests/: the only target (migration_tests) was guarded by
  NOT RELEASE_BUILD, so nothing in tests/ compiles in this branch's
  release build.
- Replace tests/CMakeLists.txt with a configure-only placeholder so the
  unconditional ADD_SUBDIRECTORY(tests) from the root CMakeLists stays
  resolvable without emitting the 'No migration test sources found'
  warning or triggering the GTest FetchContent fallback.
- Scope new_docker_build.sh (1672 -> 694 lines) to this branch: keep the
  prebuilt-image build/use/delete flow, .envrc/MIGRATE_PIPELINE_ROOT and
  rti_license validation, the release-scope in-container cmake/make/ctest
  and the Jenkins builder package production. Remove the GROUP1-11
  target lists and options, viewer-only, grantlee/arcgis/codification
  toggles, tests-only, integration-test and verify-rpm machinery.
This commit is contained in:
berrux-dev committed 2026-10-13 21:21:52 +02:00
1 parent a3ff160086
commit a32481de09
210 files changed
+108 -9627

No files matched your search

File diff suppressed because it is too large. Load diff
@@ -1,466 +1,4 @@
# CMakeLists.txt für Qt6-Migrationstests
# Diese Tests validieren BUILD_RTI Guards, Qt6-Kompatibilität und RTI-Integration
cmake_minimum_required(VERSION 3.16)
# Qt6 finden (wird vom Hauptprojekt gesetzt, aber sicherheitshalber hier auch)
if(QT6_GUI_AVAILABLE)
# Check if targets already exist from parent CMakeLists.txt
if(TARGET Qt6::Core AND TARGET Qt6::Gui AND TARGET Qt6::Widgets AND TARGET Qt6::Test)
# Already found by parent - use existing targets
elseif(NOT TARGET Qt6::Gui OR NOT TARGET Qt6::Widgets)
# Manual fallback: create imported targets when standard find fails due to OpenGL
if(NOT TARGET Qt6::Gui)
add_library(Qt6::Gui SHARED IMPORTED)
set_target_properties(Qt6::Gui PROPERTIES
IMPORTED_LOCATION "/usr/lib/x86_64-linux-gnu/libQt6Gui.so.6"
INTERFACE_INCLUDE_DIRECTORIES "/usr/include/x86_64-linux-gnu/qt6/QtGui;/usr/include/x86_64-linux-gnu/qt6"
)
endif()
if(NOT TARGET Qt6::Widgets)
add_library(Qt6::Widgets SHARED IMPORTED)
set_target_properties(Qt6::Widgets PROPERTIES
IMPORTED_LOCATION "/usr/lib/x86_64-linux-gnu/libQt6Widgets.so.6"
INTERFACE_INCLUDE_DIRECTORIES "/usr/include/x86_64-linux-gnu/qt6/QtWidgets;/usr/include/x86_64-linux-gnu/qt6"
INTERFACE_LINK_LIBRARIES "Qt6::Gui;Qt6::Core"
)
endif()
else()
# Try standard find_package first, fall back to manual targets if OpenGL missing
find_package(Qt6 QUIET COMPONENTS Core Gui Widgets Test)
endif()
# Ensure Core and Test are found
if(NOT TARGET Qt6::Core)
find_package(Qt6 REQUIRED COMPONENTS Core Test)
endif()
else()
if(NOT TARGET Qt6::Core OR NOT TARGET Qt6::Test)
find_package(Qt6 REQUIRED COMPONENTS Core Test)
endif()
endif()
# Nur bauen wenn BUILD_TESTING aktiviert ist
if(BUILD_TESTING)
# Try to find system-wide GTest first, fallback to FetchContent
find_package(GTest QUIET)
if(NOT TARGET GTest::gtest_main)
include(FetchContent)
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG v1.13.0
)
# For Windows: Prevent overriding the parent project's compiler/linker settings
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)
endif()
# Collect all test source files dynamically
file(GLOB MIGRATION_TEST_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/test_*.cpp")
if(MIGRATION_TEST_SOURCES)
set(EXISTING_SOURCES ${MIGRATION_TEST_SOURCES})
# Exclude tests for non-existent or commented-out components
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_lts_app_descriptor_editor\\.cpp")
# Exclude Qt Test-based tests (conflict with gtest main())
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_lts_app_descriptor\\.cpp")
# Exclude Grantlee-related tests when BUILD_GRANTLEE is OFF
if(NOT BUILD_GRANTLEE)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_.*Grantlee.*\\.cpp")
message(STATUS "Migration tests: Grantlee support disabled (BUILD_GRANTLEE=OFF), excluded Grantlee tests")
endif()
# Exclude CodeGen tests when CodeGen targets aren't available (MIGRATE_MODULE restricts scope)
if(NOT TARGET codegen_base)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_StructBuilder\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_SqlGenerator\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_XmlReader\\.cpp")
message(STATUS "Migration tests: CodeGen targets not available, excluded CodeGen tests")
endif()
# Exclude LtsTimelineClassic tests when LtsTimelineClassic target isn't available
if(NOT TARGET LtsTimelineClassic)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_abstracttimelinemodel\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_event\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_eventdelegate\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_eventgraphic\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_eventlist\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_eventtools\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_item\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_ltsclassicdatamodel\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_ltsclassicfilterproxymodel\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_passiveeventcontainer\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_testtimelinemodel\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_timelineheaderview\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_timelineindicator\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_timelineview\\.cpp")
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_timelinewidget\\.cpp")
message(STATUS "Migration tests: LtsTimelineClassic target not available, excluded LtsTimelineClassic tests")
endif()
# Exclude LTS Tools tests when corresponding targets aren't available
if(NOT TARGET dbAdministration)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DBAdministration\\.cpp")
endif()
if(NOT TARGET SettingsRemover)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DBOperatorSettingsRemover\\.cpp")
endif()
if(NOT TARGET dbUpdate)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DBUpdate\\.cpp")
endif()
if(NOT TARGET tDataSampleGenerator)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DataSampleGenerator\\.cpp")
endif()
if(NOT TARGET tDataSampleReceiver)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DataSampleReceiver\\.cpp")
endif()
if(NOT TARGET DateTimeSyncer)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DateTimeSyncer\\.cpp")
endif()
if(NOT TARGET ddsview)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DdsView\\.cpp")
endif()
if(NOT TARGET displayPanelSimulator)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_DotMatrixDisplay\\.cpp")
endif()
if(NOT TARGET LicenceEditor)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_LicenceEditor\\.cpp")
endif()
if(NOT TARGET localDomainFinder)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_LocalDomainFinder\\.cpp")
endif()
if(NOT TARGET LogViewer)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_LogViewer\\.cpp")
endif()
# Group 7 (A,B,C,E,I) exclusions
if(NOT TARGET AdlerWebSocketSimulator)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_AdlerWebSocketSimulator\\.cpp")
endif()
if(NOT TARGET AsmWorkstationCertifier)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_AsmWorkstationCertifier\\.cpp")
endif()
if(NOT TARGET CnrProxyTester)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_CnrProxyTester\\.cpp")
endif()
if(NOT TARGET ConfigX)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_ConfigX\\.cpp")
endif()
if(NOT TARGET EEMFakeServer)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_EEMFakeServer\\.cpp")
endif()
if(NOT TARGET egcuSimulator)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_egcuSimulator\\.cpp")
endif()
# Group 8 (J,M,N,P,Q) exclusions
if(NOT TARGET ParticipantDataGenerator)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_ParticipantDataGenerator\\.cpp")
endif()
if(NOT TARGET ProjectSettingsEditor)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_ProjectSettingsEditor\\.cpp")
endif()
if(NOT TARGET qledline)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_QLedLine\\.cpp")
endif()
if(NOT TARGET qledmatrix)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_QLedMatrix\\.cpp")
endif()
# Group 9 (R,S,T,V,W) exclusions
if(NOT TARGET RestClientUi)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_RestClientUi\\.cpp")
endif()
if(NOT TARGET ScreenIdShow)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_ScreenIdShow\\.cpp")
endif()
if(NOT TARGET SerialToTcpConverter)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_SerialToTcpConverter\\.cpp")
endif()
if(NOT TARGET Splash)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_Splash\\.cpp")
endif()
if(NOT TARGET SqlBrowser)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_SqlBrowser\\.cpp")
endif()
if(NOT TARGET TextEditorTest)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_TextEditorTest\\.cpp")
endif()
if(NOT TARGET Times)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_Times\\.cpp")
endif()
if(NOT TARGET TopicDiscover)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_TopicDiscover\\.cpp")
endif()
if(NOT TARGET TrajectoryWidget)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_TrajectoryWidget\\.cpp")
endif()
if(NOT TARGET VapixConfig)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_VapixConfig\\.cpp")
endif()
if(NOT TARGET VideoImport)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_VideoImport\\.cpp")
endif()
if(NOT TARGET WlsRandomPositions)
list(FILTER EXISTING_SOURCES EXCLUDE REGEX "test_WlsRandomPositions\\.cpp")
endif()
if(NOT EXISTING_SOURCES)
message(WARNING "No migration test sources found after filtering - skipping migration_tests target")
return()
endif()
# Skip tests in release scope builds
if(NOT RELEASE_BUILD)
add_executable(migration_tests ${EXISTING_SOURCES})
# FLM/FLT tests include build-tree generated headers (flm_[dtc|ftc|enums],
# flt_[dtc|ftc|enums]) - make sure codegen of these services ran first.
if(TARGET svcFlmCommon)
add_dependencies(migration_tests svcFlmCommon)
endif()
if(TARGET svcFltCommon)
add_dependencies(migration_tests svcFltCommon)
endif()
# The *_dtc/*_enums tests include the rtiddsgen/codegen outputs of
# the migrated services from ${CMAKE_BINARY_DIR}/Lts/Services. The
# OFF-era stub copies these tests used to resolve (include/ and
# Lts/Services source stubs) were removed, so the codegen of each
# service must run before migration_tests compiles - the same
# ordering the svcFlmCommon/svcFltCommon blocks above provide.
# Nothing else in the docker_build.sh make list builds these
# service targets, so without these deps the generated headers are
# missing on a fresh build.
foreach(_svc_common IN ITEMS
svcAesCommon svcAlmCommon svcAsmCommon svcAvmCommon svcCodCommon
svcEemCommon svcEsmCommon svcEscCommon svcEvlCommon svcExmCommon
svcGimCommon svcIsmCommon svcMdmCommon svcMsgCommon svcMrkCommon
svcNomCommon svcNmeCommon svcOpmCommon svcOssCommon svcPdmCommon
svcPpmCommon
svcPreCommon svcRepCommon svcSomCommon svcSrmCommon svcSrpCommon
svcTgtCommon svcWhgCommon)
if(TARGET ${_svc_common})
add_dependencies(migration_tests ${_svc_common})
endif()
endforeach()
# test_ces_dtc / test_scm_dtc include the CentralEffectSimulation and
# ServiceManagement rtiddsgen/codegen outputs (ces_dtc.h, scm_dtc.h)
# from build4/Lts/Services; test_cmo_dtc / test_gna_dtc include the
# ComponentMonitor and GuezNasat outputs (cmo_dtc.h, gna_dtc.h) from
# build4/Lts/Proxies. Same ordering requirement as the blocks above:
# without these deps a parallel make can start migration_tests before
# those headers exist.
foreach(_extra_common IN ITEMS
svcCesCommon svcCmoCommon svcGnaCommon svcScmCommon)
if(TARGET ${_extra_common})
add_dependencies(migration_tests ${_extra_common})
endif()
endforeach()
# test_core_enums includes Lts/DDS/Core/core_enums.hpp, an rtiddsgen
# output built by ddscore. ddscore is in the make target list, but a
# parallel make gives no ordering between it and migration_tests.
if(TARGET ddscore)
add_dependencies(migration_tests ddscore)
endif()
# test_tab_dtc includes the TrainingAreaBase rtiddsgen/codegen
# outputs (tab.hpp, tab_dtc.h) from build4/Lts/Proxies - same
# ordering requirement as the service blocks above.
if(TARGET svcTabCommon)
add_dependencies(migration_tests svcTabCommon)
endif()
# test_taboc_dtc includes the TrainingAreaBaseOC outputs
# (taboc.hpp, taboc_dtc.h) from build4/Lts/Proxies likewise.
if(TARGET svcTabocCommon)
add_dependencies(migration_tests svcTabocCommon)
endif()
# test_bld_dtc / test_bld_enums include the Buildings outputs
# (bld.hpp, bld_dtc.h, bld_enums.hpp) from build4/Lts/Proxies
# likewise (the CONFIGURE_FILE stub copy was removed).
if(TARGET svcBldCommon)
add_dependencies(migration_tests svcBldCommon)
endif()
# test_nme_dtc / test_nmea_handler include the server-topic
# interfaces (nme_dts.h, nme_fts.h) that CODEGEN_SERVER_TOPICS
# generates into the svcNmeServer target - same ordering
# requirement as the blocks above (without it a parallel make
# can start migration_tests before those headers exist).
if(TARGET svcNmeServer)
add_dependencies(migration_tests svcNmeServer)
endif()
# Enable Qt Meta-Object Compiler for tests with Q_OBJECT
set_target_properties(migration_tests PROPERTIES AUTOMOC ON)
target_compile_features(migration_tests PRIVATE cxx_std_17)
# BEFORE: the root CMakeLists' include_directories() puts include/ early
# on the path, so the BUILD_RTI=OFF stub variant of DDS/Generic would
# shadow the real DDS framework headers that the generated flm/flt
# service headers pull in — same fix the service CMakeLists enforce
# with include_directories(BEFORE ${CMAKE_SOURCE_DIR}/Lts).
target_include_directories(migration_tests BEFORE PRIVATE
${CMAKE_SOURCE_DIR}/Lts
)
target_include_directories(migration_tests PRIVATE
${CMAKE_SOURCE_DIR}
${CMAKE_SOURCE_DIR}/include
${CMAKE_BINARY_DIR}/Lts
${CMAKE_BINARY_DIR}/Lts/Common
${CMAKE_BINARY_DIR}/Lts/Common/CodeGen
${CMAKE_BINARY_DIR}/Lts/Common/LtsTimeline
${CMAKE_SOURCE_DIR}/Lts/Common/LtsTimelineClassic
${CMAKE_BINARY_DIR}/Lts/Services
${CMAKE_SOURCE_DIR}/Lts/Services
${CMAKE_SOURCE_DIR}/Lts/Proxies
${CMAKE_BINARY_DIR}/Lts/Proxies
# Source headers under Lts/DDS/DDSConnector and
# Lts/Common/LtsCoordTrans include their build-tree export
# headers by bare quoted name (ddsconnector_export.h,
# ltscoordtrans_export.h); the OFF-stub copies under include/
# that used to satisfy those includes were removed.
${CMAKE_BINARY_DIR}/Lts/DDS/DDSConnector
${CMAKE_BINARY_DIR}/Lts/Common/LtsCoordTrans
${CMAKE_SOURCE_DIR}/Z/src/NGLLogger
# Core/core_dtc.h resolves to the ddscore codegen output
# (build-dir Lts/DDS/Core/core_dtc.h); DDS/DTC/generic_dtc.h
# resolves to the real Lts/DDS/DTC header. Appended last so they
# have the lowest include precedence (no shadowing).
${CMAKE_SOURCE_DIR}/Lts
${CMAKE_BINARY_DIR}/Lts/DDS
)
# test_flm_dtc_impl_custom.cpp includes flm_dtc_impl_custom.h, which
# pulls in the generated flm_dtc_impl.h. Its include guard requires
# MAKE_SVCFLMCLIENT_LIB (defined by NGL_ADD_LIBRARY on svcFlmClient,
# which compiles flm_dtc_impl_custom.cpp).
target_compile_definitions(migration_tests PRIVATE MAKE_SVCFLMCLIENT_LIB)
# test_CppTopicGeneratorGrantlee.cpp bootstraps the NGL root logger
# before constructing the generator. The <NGLLogger/...> headers
# resolve via Z/src, the generated ngllogger_export.h via the
# library's binary dir.
target_include_directories(migration_tests PRIVATE
${CMAKE_SOURCE_DIR}/Z/src
${CMAKE_BINARY_DIR}/Z/src/NGLLogger
)
# Export-header tests locate generated headers in the build tree.
# The directory name is not stable across pipeline stages (build4),
# so the path is passed in instead of being hardcoded.
target_compile_definitions(migration_tests PRIVATE MIGRATION_TEST_BUILD_DIR="${CMAKE_BINARY_DIR}")
# Link against Qt6 components (Qt6::Test not needed - using gtest)
if(QT6_GUI_AVAILABLE)
target_link_libraries(migration_tests PRIVATE
Qt6::Core
Qt6::Gui
Qt6::Widgets
GTest::gtest_main
)
else()
target_link_libraries(migration_tests PRIVATE
Qt6::Core
GTest::gtest_main
)
endif()
# Link against Z-module libraries for integration tests
# These are the core NGL libraries migrated to Qt6
if(TARGET NGLLogger)
target_link_libraries(migration_tests PRIVATE NGLLogger)
endif()
if(TARGET ngltools)
target_link_libraries(migration_tests PRIVATE ngltools)
endif()
if(TARGET ngldb)
target_link_libraries(migration_tests PRIVATE ngldb)
endif()
if(TARGET nglsettings)
target_link_libraries(migration_tests PRIVATE nglsettings)
endif()
if(TARGET ngltranslator)
target_link_libraries(migration_tests PRIVATE ngltranslator)
endif()
if(TARGET nglcompression)
target_link_libraries(migration_tests PRIVATE nglcompression)
endif()
if(TARGET tcpserver)
target_link_libraries(migration_tests PRIVATE tcpserver)
endif()
if(TARGET nglapplication)
target_link_libraries(migration_tests PRIVATE nglapplication)
endif()
if(TARGET qtsingleapplication)
target_link_libraries(migration_tests PRIVATE qtsingleapplication)
endif()
if(TARGET wms_json_ds)
target_link_libraries(migration_tests PRIVATE wms_json_ds)
endif()
if(TARGET nglwidgets AND QT6_GUI_AVAILABLE)
target_link_libraries(migration_tests PRIVATE nglwidgets)
endif()
# NmeaManagement tests instantiate the generated nme types (nme.hpp
# default ctors, ServiceControlEnum stream operator) and the service
# logger (logger.cpp) - both compiled into svcNmeCommon.
if(TARGET svcNmeCommon)
target_link_libraries(migration_tests PRIVATE svcNmeCommon)
endif()
# FLM/FLT service tests include the Q_OBJECT custom headers of the
# migrated services (flm_db_impl_custom.h, flm_dtc_impl_custom.h).
# Their moc output references the generated bases' staticMetaObject
# (DatabaseInterface, DtcImpl) defined in the service libraries.
if(TARGET svcFlmCommon)
target_link_libraries(migration_tests PRIVATE svcFlmCommon)
endif()
if(TARGET svcFlmClient)
target_link_libraries(migration_tests PRIVATE svcFlmClient)
endif()
# Link against LtsTimelineClassic only if it exists (may not exist with MIGRATE_MODULE)
if(TARGET LtsTimelineClassic)
target_link_libraries(migration_tests PRIVATE LtsTimelineClassic)
add_dependencies(migration_tests LtsTimelineClassic)
else()
message(STATUS "LtsTimelineClassic target not available - skipping link (MIGRATE_MODULE may restrict scope)")
endif()
# Grantlee tests require BUILD_GRANTLEE=ON
if(BUILD_GRANTLEE)
target_link_libraries(migration_tests PRIVATE codegen_grantlee)
target_include_directories(migration_tests PRIVATE
${CMAKE_SOURCE_DIR}/Lts/Common/CodeGen
)
message(STATUS "Migration tests: Grantlee support enabled")
endif()
# RTI libraries if BUILD_RTI is ON
if(BUILD_RTI)
find_package(RTI QUIET)
if(RTI_FOUND)
target_include_directories(migration_tests PRIVATE ${RTI_INCLUDE_DIRS})
target_link_libraries(migration_tests PRIVATE ${RTI_LIBRARIES})
target_compile_definitions(migration_tests PRIVATE BUILD_RTI=1)
message(STATUS "RTI found: ${RTI_LIBRARIES}")
else()
message(STATUS "BUILD_RTI=ON but RTI not found - building tests without RTI")
endif()
endif()
# Register with CTest
include(GoogleTest)
gtest_discover_tests(migration_tests)
message(STATUS "Migration tests enabled: ${EXISTING_SOURCES}")
endif() # NOT RELEASE_BUILD
else()
message(WARNING "No migration test sources found in ${CMAKE_CURRENT_SOURCE_DIR}")
endif()
endif()
# Validation-scope branch: no test sources are shipped and nothing in this
# directory is built by the release build (the former migration_tests target
# was guarded by NOT RELEASE_BUILD). This file only keeps the unconditional
# ADD_SUBDIRECTORY(tests) from the root CMakeLists.txt resolvable.
@@ -1,20 +0,0 @@
#pragma once
#include <utility>
// Minimal realistic mock for coordinate transforms used during migration.
// Forward conversion returns approximate meters using lat/lon*111000.
class MockCoordTrans
{
public:
// approximate forward: (lat, lon) -> (x_m, y_m)
static std::pair<double, double> forward(double lat_deg, double lon_deg)
{
return {lat_deg * 111000.0, lon_deg * 111000.0};
}
// approximate inverse
static std::pair<double, double> inverse(double x_m, double y_m)
{
return {x_m / 111000.0, y_m / 111000.0};
}
};
@@ -1,14 +0,0 @@
#include "mocks/MockCoordTrans.h"
#include <gtest/gtest.h>
TEST(CoordTransGTest, ForwardInverseRoundtrip)
{
auto p = MockCoordTrans::forward(1.2345, 2.3456);
EXPECT_NEAR(p.first, 1.2345 * 111000.0, 1e-6);
EXPECT_NEAR(p.second, 2.3456 * 111000.0, 1e-6);
auto inv = MockCoordTrans::inverse(p.first, p.second);
EXPECT_NEAR(inv.first, 1.2345, 1e-9);
EXPECT_NEAR(inv.second, 2.3456, 1e-9);
}
@@ -1,19 +0,0 @@
#include "mocks/MockCoordTrans.h"
#include <QtTest/QtTest>
class CoordTransSmoke : public QObject
{
Q_OBJECT
private slots:
void testForward()
{
auto p = MockCoordTrans::forward(10.0, 20.0);
QVERIFY(qFuzzyCompare(p.first, 10.0 * 111000.0));
QVERIFY(qFuzzyCompare(p.second, 20.0 * 111000.0));
}
};
QTEST_MAIN(CoordTransSmoke)
#include "coordTransTests_smoke.moc"
@@ -1,22 +0,0 @@
/**
* @file test_AdlerWebSocketSimulator.cpp
* @brief CTest for AdlerWebSocketSimulator (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(AdlerWebSocketSimulatorTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(AdlerWebSocketSimulatorTest, Qt6ApiCompatibility) {
// Verify Qt6 network/websocket APIs are accessible
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(AdlerWebSocketSimulatorTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_AsmWorkstationCertifier.cpp
* @brief CTest for AsmWorkstationCertifier (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(AsmWorkstationCertifierTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(AsmWorkstationCertifierTest, Qt6ApiCompatibility) {
// Verify Qt6 APIs are accessible
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(AsmWorkstationCertifierTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_CnrProxyTester.cpp
* @brief CTest for CnrProxyTester (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(CnrProxyTesterTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(CnrProxyTesterTest, Qt6ApiCompatibility) {
// Verify Qt6 APIs are accessible
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(CnrProxyTesterTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_ConfigX.cpp
* @brief CTest for ConfigX (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(ConfigXTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(ConfigXTest, Qt6ApiCompatibility) {
// Verify Qt6 APIs are accessible (QScreen, QGuiApplication)
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(ConfigXTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,46 +0,0 @@
#include "CppTopicGeneratorGrantlee.h"
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <gtest/gtest.h>
namespace
{
// GeneratorGrantleeBase acquires its logger from the NGL root logger in its
// constructor. getNGLRootLogger() throws NotCreatedError as long as no root
// logger was created, so the test has to bootstrap one first. An empty
// configuration falls back to WARN logging on stdout ('quiet' suppresses
// the notice on stderr); 'ignorealreadycreated' keeps repeat calls
// idempotent across tests of this binary.
NGL::INGLLogger& ensureRootLogger()
{
return NGL::NGLLoggerBootstrap::createNGLRootLogger(QString(), true, QString(), true);
}
} // namespace
// Test that CppTopicGeneratorGrantlee can be instantiated
TEST(CppTopicGeneratorGrantleeTest, CanInstantiate)
{
ensureRootLogger();
// Constructor acquires the logger from the root logger and must not throw
EXPECT_NO_THROW({ CodeGen::CppTopicGeneratorGrantlee generator; });
}
// Test that the generator has expected base class functionality
TEST(CppTopicGeneratorGrantleeTest, HasLoggerName)
{
ensureRootLogger();
CodeGen::CppTopicGeneratorGrantlee generator;
// The base class created its "CodeGen.CppTopicGeneratorGrantlee" logger
// from the root logger — retrieving that logger must not throw.
EXPECT_NO_THROW(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("CodeGen.CppTopicGeneratorGrantlee"));
}
// Test compilation of header dependencies
TEST(CppTopicGeneratorGrantleeTest, HeaderCompiles)
{
// This test verifies that all headers included by CppTopicGeneratorGrantlee.cpp
// compile correctly with Qt6/C++23
// Includes: CppTopicGeneratorGrantlee.h, StructBuilder.h, NGLLogger, QCryptographicHash, grantlee/context.h
EXPECT_TRUE(true); // Compilation itself is the test
}
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Test for DBAdministration tool migration validation
// Tests compilation and basic Qt6 API compatibility
namespace DBAdministration
{
// Forward declaration to verify compilation
class DBAdministration;
} // namespace DBAdministration
TEST(DBAdministrationMigrationTest, CompilationStub)
{
// Verify that DBAdministration compiles and links correctly after Qt6 migration
// The main class uses QtWidgets, QSqlDatabase, QProcess
EXPECT_TRUE(true);
}
TEST(DBAdministrationMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for database and process handling
// DBAdministration uses:
// - QSqlDatabase (Qt6::Sql)
// - QProcess (Qt6::Core)
// - QMainWindow, QStandardItemModel (Qt6::Widgets)
EXPECT_TRUE(true);
}
TEST(DBAdministrationMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for database administration operations could be added here
EXPECT_TRUE(true);
}
@@ -1,35 +0,0 @@
#include <gtest/gtest.h>
// Test for DBOperatorSettingsRemover tool migration validation
// Simple tool that removes operator settings from database
namespace DBOperatorSettingsRemover
{
// Forward declaration to verify compilation
// Main functionality is in main.cpp
} // namespace DBOperatorSettingsRemover
TEST(DBOperatorSettingsRemoverMigrationTest, CompilationStub)
{
// Verify that DBOperatorSettingsRemover compiles and links correctly after Qt6 migration
// Uses Qt6::Core and Qt6::Sql for database operations
EXPECT_TRUE(true);
}
TEST(DBOperatorSettingsRemoverMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for database operations
// DBOperatorSettingsRemover uses:
// - QSqlDatabase, QSqlQuery (Qt6::Sql)
// - QCoreApplication (Qt6::Core)
EXPECT_TRUE(true);
}
TEST(DBOperatorSettingsRemoverMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for database operator settings removal could be added here
EXPECT_TRUE(true);
}
@@ -1,39 +0,0 @@
#include <gtest/gtest.h>
// Test for DBUpdate tool migration validation
// Tests compilation and basic Qt6 API compatibility
namespace DBUpdate
{
// Forward declarations to verify compilation
class DBUpdate;
class ExercisesModel;
class GlobalUpdatesModel;
class HistoryModel;
} // namespace DBUpdate
TEST(DBUpdateMigrationTest, CompilationStub)
{
// Verify that DBUpdate compiles and links correctly after Qt6 migration
// The main class uses QtWidgets, QSqlDatabase, and multiple model classes
EXPECT_TRUE(true);
}
TEST(DBUpdateMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for database and model operations
// DBUpdate uses:
// - QSqlDatabase, QSqlQuery (Qt6::Sql)
// - QMainWindow, QStandardItemModel (Qt6::Widgets)
// - QProcess (Qt6::Core)
EXPECT_TRUE(true);
}
TEST(DBUpdateMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for database update operations and model handling could be added here
EXPECT_TRUE(true);
}
@@ -1,23 +0,0 @@
#include <gtest/gtest.h>
// Header compilation test for DaoGeneratorGrantlee
#include "Lts/Common/CodeGen/DaoGeneratorGrantlee.h"
TEST(DaoGeneratorGrantleeTest, HeaderCompiles)
{
// Verify header compiles without errors
EXPECT_TRUE(true);
}
TEST(DaoGeneratorGrantleeTest, CanInstantiate)
{
// Basic instantiation test (may need adjustment based on actual constructor)
// This is a stub test to satisfy policy requirements
EXPECT_TRUE(true);
}
TEST(DaoGeneratorGrantleeTest, NamespaceExists)
{
// Verify namespace exists
EXPECT_TRUE(true);
}
@@ -1,57 +0,0 @@
#include <gtest/gtest.h>
// Test for DataSampleGenerator tool migration validation
// Tests compilation and basic Qt6 API compatibility
// Note: This tool requires RTI DDS libraries (BUILD_RTI=ON)
namespace DataSampleGenerator
{
// Forward declarations to verify compilation
class Initialisation;
} // namespace DataSampleGenerator
#ifdef BUILD_RTI
TEST(DataSampleGeneratorMigrationTest, CompilationStub)
{
// Verify that DataSampleGenerator compiles and links correctly after Qt6 migration
// Uses RTI DDS libraries and Qt6::Core
EXPECT_TRUE(true);
}
TEST(DataSampleGeneratorMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for DDS data generation
// DataSampleGenerator uses:
// - RTI::nddsc, RTI::nddscore (RTI DDS)
// - QCoreApplication (Qt6::Core)
// - topicdiscover, topic_type_plugin (RTI)
EXPECT_TRUE(true);
}
TEST(DataSampleGeneratorMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for DDS data sample generation could be added here
EXPECT_TRUE(true);
}
#else
TEST(DataSampleGeneratorMigrationTest, CompilationStub)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
TEST(DataSampleGeneratorMigrationTest, Qt6ApiCompatibility)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
TEST(DataSampleGeneratorMigrationTest, BasicFunctionality)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
#endif
@@ -1,58 +0,0 @@
#include <gtest/gtest.h>
// Test for DataSampleReceiver tool migration validation
// Tests compilation and basic Qt6 API compatibility
// Note: This tool requires RTI DDS libraries (BUILD_RTI=ON)
namespace DataSampleReceiver
{
// Forward declarations to verify compilation
class Initialisation;
class TopicData;
} // namespace DataSampleReceiver
#ifdef BUILD_RTI
TEST(DataSampleReceiverMigrationTest, CompilationStub)
{
// Verify that DataSampleReceiver compiles and links correctly after Qt6 migration
// Uses RTI DDS libraries and Qt6::Core
EXPECT_TRUE(true);
}
TEST(DataSampleReceiverMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for DDS data reception
// DataSampleReceiver uses:
// - RTI::nddsc, RTI::nddscore (RTI DDS)
// - QCoreApplication (Qt6::Core)
// - topicdiscover, topic_type_plugin (RTI)
EXPECT_TRUE(true);
}
TEST(DataSampleReceiverMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for DDS data sample reception could be added here
EXPECT_TRUE(true);
}
#else
TEST(DataSampleReceiverMigrationTest, CompilationStub)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
TEST(DataSampleReceiverMigrationTest, Qt6ApiCompatibility)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
TEST(DataSampleReceiverMigrationTest, BasicFunctionality)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
#endif
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/DatabaseGeneratorGrantlee.h"
#include <gtest/gtest.h>
TEST(DatabaseGeneratorGrantleeTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(DatabaseGeneratorGrantleeTest, CanInstantiate)
{
EXPECT_TRUE(true);
}
TEST(DatabaseGeneratorGrantleeTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Test for DateTimeSyncer tool migration validation
// Tests compilation and basic Qt6 API compatibility
namespace DateTimeSyncer
{
// Forward declarations to verify compilation
class SystemCaller;
class TcpServer;
} // namespace DateTimeSyncer
TEST(DateTimeSyncerMigrationTest, CompilationStub)
{
// Verify that DateTimeSyncer compiles and links correctly after Qt6 migration
// Uses Qt6::Core, Qt6::Network for TCP server and system calls
EXPECT_TRUE(true);
}
TEST(DateTimeSyncerMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for network and system operations
// DateTimeSyncer uses:
// - QTcpServer, QTcpSocket (Qt6::Network)
// - QCoreApplication (Qt6::Core)
EXPECT_TRUE(true);
}
TEST(DateTimeSyncerMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for time synchronization and TCP server operations could be added here
EXPECT_TRUE(true);
}
@@ -1,58 +0,0 @@
#include <gtest/gtest.h>
// Test for DdsView tool migration validation
// Tests compilation and basic Qt6 API compatibility
// Note: This tool requires RTI DDS libraries (BUILD_RTI=ON)
namespace DdsView
{
// Forward declarations to verify compilation
class DdsView;
class TopicModel;
} // namespace DdsView
#ifdef BUILD_RTI
TEST(DdsViewMigrationTest, CompilationStub)
{
// Verify that DdsView compiles and links correctly after Qt6 migration
// Uses RTI DDS libraries and Qt6::Widgets
EXPECT_TRUE(true);
}
TEST(DdsViewMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for DDS visualization
// DdsView uses:
// - RTI::nddsc, RTI::nddscore (RTI DDS)
// - QMainWindow, QTreeView (Qt6::Widgets)
// - topicdiscover, topic_type_plugin (RTI)
EXPECT_TRUE(true);
}
TEST(DdsViewMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for DDS topic visualization could be added here
EXPECT_TRUE(true);
}
#else
TEST(DdsViewMigrationTest, CompilationStub)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
TEST(DdsViewMigrationTest, Qt6ApiCompatibility)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
TEST(DdsViewMigrationTest, BasicFunctionality)
{
// RTI not available - stub test
EXPECT_TRUE(true);
}
#endif
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Test for DotMatrixDisplay tool migration validation
// Tests compilation and basic Qt6 API compatibility
namespace DotMatrixDisplay
{
// Forward declarations to verify compilation
class DotMatrixDisplay;
class DotMatrixWidget;
} // namespace DotMatrixDisplay
TEST(DotMatrixDisplayMigrationTest, CompilationStub)
{
// Verify that DotMatrixDisplay compiles and links correctly after Qt6 migration
// Uses Qt6::Widgets for GUI display
EXPECT_TRUE(true);
}
TEST(DotMatrixDisplayMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for display rendering
// DotMatrixDisplay uses:
// - QMainWindow, QWidget (Qt6::Widgets)
// - QPainter, QFont (Qt6::Gui)
EXPECT_TRUE(true);
}
TEST(DotMatrixDisplayMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for dot matrix display rendering could be added here
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_EEMFakeServer.cpp
* @brief CTest for EEMFakeServer (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(EEMFakeServerTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(EEMFakeServerTest, Qt6ApiCompatibility) {
// Verify Qt6 network/websocket APIs are accessible
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(EEMFakeServerTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/GeneratorGrantleeBase.h"
#include <gtest/gtest.h>
TEST(GeneratorGrantleeBaseTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(GeneratorGrantleeBaseTest, CanInstantiate)
{
EXPECT_TRUE(true);
}
TEST(GeneratorGrantleeBaseTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/GrantleeParserSmoke.h"
#include <gtest/gtest.h>
TEST(GrantleeParserSmokeTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(GrantleeParserSmokeTest, CanInstantiate)
{
EXPECT_TRUE(true);
}
TEST(GrantleeParserSmokeTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/GrantleeWrappers.h"
#include <gtest/gtest.h>
TEST(GrantleeWrappersTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(GrantleeWrappersTest, CanInstantiate)
{
EXPECT_TRUE(true);
}
TEST(GrantleeWrappersTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,35 +0,0 @@
#include <gtest/gtest.h>
// Test for LicenceEditor tool migration validation
// Tests compilation and basic Qt6 API compatibility
namespace LicenceEditor
{
// Forward declarations to verify compilation
class LicenceEditor;
} // namespace LicenceEditor
TEST(LicenceEditorMigrationTest, CompilationStub)
{
// Verify that LicenceEditor compiles and links correctly after Qt6 migration
// Uses Qt6::Widgets for GUI license editing
EXPECT_TRUE(true);
}
TEST(LicenceEditorMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for license editing
// LicenceEditor uses:
// - QMainWindow, QTextEdit (Qt6::Widgets)
// - QFile, QTextStream (Qt6::Core)
EXPECT_TRUE(true);
}
TEST(LicenceEditorMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for license file editing could be added here
EXPECT_TRUE(true);
}
@@ -1,35 +0,0 @@
#include <gtest/gtest.h>
// Test for LocalDomainFinder tool migration validation
// Tests compilation and basic Qt6 API compatibility
namespace LocalDomainFinder
{
// Forward declarations to verify compilation
class LocalDomainFinder;
} // namespace LocalDomainFinder
TEST(LocalDomainFinderMigrationTest, CompilationStub)
{
// Verify that LocalDomainFinder compiles and links correctly after Qt6 migration
// Uses Qt6::Core for network discovery
EXPECT_TRUE(true);
}
TEST(LocalDomainFinderMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for domain discovery
// LocalDomainFinder uses:
// - QCoreApplication (Qt6::Core)
// - Network discovery functionality
EXPECT_TRUE(true);
}
TEST(LocalDomainFinderMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for local domain discovery could be added here
EXPECT_TRUE(true);
}
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Test for LogViewer tool migration validation
// Tests compilation and basic Qt6 API compatibility
namespace LogViewer
{
// Forward declarations to verify compilation
class LogViewer;
class LogModel;
} // namespace LogViewer
TEST(LogViewerMigrationTest, CompilationStub)
{
// Verify that LogViewer compiles and links correctly after Qt6 migration
// Uses Qt6::Widgets for log display and Qt6::Sql for database access
EXPECT_TRUE(true);
}
TEST(LogViewerMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility for log viewing
// LogViewer uses:
// - QMainWindow, QTableView (Qt6::Widgets)
// - QSqlDatabase, QSqlQuery (Qt6::Sql)
EXPECT_TRUE(true);
}
TEST(LogViewerMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// Tests for log viewing and filtering could be added here
EXPECT_TRUE(true);
}
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Stub test for LtsCommandLineParser.cpp migration validation
// Actual implementation tests should be added based on LtsCommandLineParser.cpp functionality
namespace Lts
{
namespace Common
{
// Forward declarations to verify compilation
// TODO: Add actual class/function declarations from LtsCommandLineParser
} // namespace Common
} // namespace Lts
TEST(LtsCommandLineParserMigrationTest, CompilationStub)
{
// Verify that LtsCommandLineParser.cpp compiles and links correctly after Qt6 migration
// TODO: Add actual tests for LtsCommandLineParser functionality
EXPECT_TRUE(true);
}
TEST(LtsCommandLineParserMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility
// TODO: Add tests for any Qt6-specific API changes in LtsCommandLineParser.cpp
EXPECT_TRUE(true);
}
TEST(LtsCommandLineParserMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// TODO: Implement actual functionality tests
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_ParticipantDataGenerator.cpp
* @brief CTest for ParticipantDataGenerator (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(ParticipantDataGeneratorTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(ParticipantDataGeneratorTest, Qt6ApiCompatibility) {
// Verify Qt6 APIs are accessible (QCore, QNetwork)
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(ParticipantDataGeneratorTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_ProjectSettingsEditor.cpp
* @brief CTest for ProjectSettingsEditor (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(ProjectSettingsEditorTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(ProjectSettingsEditorTest, Qt6ApiCompatibility) {
// Verify Qt6 APIs are accessible (QCore, QWidgets)
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(ProjectSettingsEditorTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_QLedLine.cpp
* @brief CTest for QLedLine (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(QLedLineTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(QLedLineTest, Qt6ApiCompatibility) {
// Verify Qt6 APIs are accessible (QCore, QWidgets)
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(QLedLineTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_QLedMatrix.cpp
* @brief CTest for QLedMatrix (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(QLedMatrixTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(QLedMatrixTest, Qt6ApiCompatibility) {
// Verify Qt6 APIs are accessible (QCore, QWidgets)
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(QLedMatrixTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/SqlGenerator.h"
#include <gtest/gtest.h>
TEST(SqlGeneratorTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(SqlGeneratorTest, CanInstantiate)
{
EXPECT_TRUE(true);
}
TEST(SqlGeneratorTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/StructBuilder.h"
#include <gtest/gtest.h>
TEST(StructBuilderTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(StructBuilderTest, CanInstantiate)
{
EXPECT_TRUE(true);
}
TEST(StructBuilderTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/XmlReader.h"
#include <gtest/gtest.h>
TEST(XmlReaderTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(XmlReaderTest, CanInstantiate)
{
EXPECT_TRUE(true);
}
TEST(XmlReaderTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,21 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/AbstractTimelineModel.h"
#include <gtest/gtest.h>
TEST(LtsAbstractTimelineModelTest, HeaderCompiles)
{
// Verify header compiles without errors
EXPECT_TRUE(true);
}
TEST(LtsAbstractTimelineModelTest, CanInstantiate)
{
// Basic instantiation test if class is instantiable
// Add specific instantiation code if class can be constructed
}
TEST(LtsAbstractTimelineModelTest, NamespaceExists)
{
// Verify namespace exists
// Add namespace verification if applicable
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for aes_crypt.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(aes_cryptMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(aes_cryptMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(aes_cryptMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for aes_crypt_test.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(aes_crypt_testMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(aes_crypt_testMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(aes_crypt_testMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,61 +0,0 @@
/**
* @file test_aes_dtc.cpp
* @brief Tests für die generierte AreaEffectSimulation Dtc/Ftc-Schnittstelle
*
* Diese Tests validieren die von CODEGEN_CLIENT_TOPICS_IFC aus aes_service.xml
* generierten Header (aes_dtc.h/aes_ftc.h) aus dem Build-Tree.
*/
#include <gtest/gtest.h>
// Include des zu testenden Headers
#include "AreaEffectSimulation/aes_dtc.h"
#include "AreaEffectSimulation/aes_ftc.h"
/**
* @test Test dass der Header kompiliert und Namespace existiert
*/
TEST(AesDtcTest, HeaderCompilesAndNamespaceExists)
{
// Verify that the namespace and forward declarations exist
// This test ensures the stub header compiles correctly
using namespace AreaEffectSimulation;
using namespace AreaEffectSimulation::Interface;
// Forward declarations should be available
// We can't instantiate them, but we can declare pointers
Dtc* dtc_ptr = nullptr;
Ftc* ftc_ptr = nullptr;
EXPECT_EQ(dtc_ptr, nullptr);
EXPECT_EQ(ftc_ptr, nullptr);
}
/**
* @test Test dass Namespace-Struktur korrekt ist
*/
TEST(AesDtcTest, NamespaceStructure)
{
// Verify nested namespace structure
using DtcType = AreaEffectSimulation::Interface::Dtc;
using FtcType = AreaEffectSimulation::Interface::Ftc;
// Type traits verification (compile-time check)
static_assert(std::is_class<DtcType>::value, "Dtc should be a class");
static_assert(std::is_class<FtcType>::value, "Ftc should be a class");
EXPECT_TRUE(true); // Compile-time checks passed
}
/**
* @test Test dass Header mehrfach inkludierbar ist (include guard)
*/
TEST(AesDtcTest, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
// This is implicitly tested by including it again here
#include "AreaEffectSimulation/aes_dtc.h"
// If we reach this point, the include guard works
EXPECT_TRUE(true);
}
@@ -1,60 +0,0 @@
/**
* @file test_aes_enums.cpp
* @brief Verhaltenstests für die generierten AreaEffectSimulation-Enumerationen
*
* Diese Tests prüfen den von rtiddsgen aus aes_enums.idl generierten Header
* (Lts/Services/AreaEffectSimulation/aes_enums.hpp) aus dem Build-Tree.
* Die Werte stammen aus aes_service.xml (z.B. AesExplosionGeometry für
* Explosionsgeometrien, AesEffectState für den Effekt-Zustandsautomaten).
*/
#include "Lts/Services/AreaEffectSimulation/aes_enums.hpp"
#include <gtest/gtest.h>
#include <type_traits>
/**
* @test AesExplosionGeometry muss mit den Werten aus aes_enums.idl generiert werden.
*/
TEST(AesEnumsTest, ExplosionGeometryValues)
{
static_assert(std::is_enum<::AreaEffectSimulation::AesExplosionGeometry>::value,
"AesExplosionGeometry muss aus aes_enums.hpp vorliegen");
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesExplosionGeometry::EgAimPoint), 0);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesExplosionGeometry::EgRadial), 1);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesExplosionGeometry::EgArea), 2);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesExplosionGeometry::EgLine), 3);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesExplosionGeometry::EgPoint), 4);
}
/**
* @test AesEffectState muss mit den Werten aus aes_enums.idl generiert werden.
*/
TEST(AesEnumsTest, EffectStateValues)
{
static_assert(std::is_enum<::AreaEffectSimulation::AesEffectState>::value,
"AesEffectState muss aus aes_enums.hpp vorliegen");
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsUnknown), 0);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsExpired), 1);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsRemoved), 2);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsCreated), 4);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsPrepared), 5);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsActivated), 6);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsPaused), 7);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsReceived), 8);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsFired), 9);
EXPECT_EQ(static_cast<int>(::AreaEffectSimulation::AesEffectState::EsError), 255);
}
/**
* @test Include-Guard: mehrfaches Einbinden des generierten Headers ist erlaubt.
*/
TEST(AesEnumsTest, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
// This is implicitly tested by including it again here
#include "Lts/Services/AreaEffectSimulation/aes_enums.hpp"
// If we reach this point, the include guard works
EXPECT_TRUE(true);
}
@@ -1,44 +0,0 @@
/**
* @file test_alm_dtc.cpp
* @brief Minimal test for the generated AlarmManagement Dtc/Ftc headers
*
* This test verifies that the headers generated by CODEGEN_CLIENT_TOPICS_IFC
* from alm_service.xml (build-tree alm_dtc.h/alm_ftc.h) compile without errors.
*/
#include <gtest/gtest.h>
#include "AlarmManagement/alm_dtc.h"
#include "AlarmManagement/alm_ftc.h"
TEST(AlarmManagementDtc, HeaderCompiles)
{
// Verify that the namespace and forward declarations exist
// This test ensures the stub header is syntactically correct
EXPECT_TRUE(true);
}
TEST(AlarmManagementDtc, ForwardDeclarationsExist)
{
// Verify forward declarations are present (compile-time check)
// If these lines compile, the forward declarations exist
AlarmManagement::Interface::Dtc* dtc_ptr = nullptr;
AlarmManagement::Interface::Ftc* ftc_ptr = nullptr;
EXPECT_EQ(dtc_ptr, nullptr);
EXPECT_EQ(ftc_ptr, nullptr);
}
TEST(AlarmManagementDtc, NamespaceStructure)
{
// Verify namespace structure exists
// This is a compile-time verification
using DtcType = AlarmManagement::Interface::Dtc;
using FtcType = AlarmManagement::Interface::Ftc;
// Suppress unused type alias warnings
(void)sizeof(DtcType*);
(void)sizeof(FtcType*);
EXPECT_TRUE(true);
}
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Stub test for app_chooser.cpp migration validation
// Actual implementation tests should be added based on app_chooser.cpp functionality
namespace Lts
{
namespace Common
{
// Forward declarations to verify compilation
class AppChooser;
} // namespace Common
} // namespace Lts
TEST(AppChooserMigrationTest, CompilationStub)
{
// Verify that app_chooser.cpp compiles and links correctly after Qt6 migration
// TODO: Add actual tests for AppChooser functionality
EXPECT_TRUE(true);
}
TEST(AppChooserMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility
// TODO: Add tests for any Qt6-specific API changes in app_chooser.cpp
EXPECT_TRUE(true);
}
TEST(AppChooserMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// TODO: Implement actual functionality tests
EXPECT_TRUE(true);
}
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Stub test for app_chooser_model.cpp migration validation
// Actual implementation tests should be added based on app_chooser_model.cpp functionality
namespace Lts
{
namespace Common
{
// Forward declarations to verify compilation
class AppChooserModel;
} // namespace Common
} // namespace Lts
TEST(AppChooserModelMigrationTest, CompilationStub)
{
// Verify that app_chooser_model.cpp compiles and links correctly after Qt6 migration
// TODO: Add actual tests for AppChooserModel functionality
EXPECT_TRUE(true);
}
TEST(AppChooserModelMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility
// TODO: Add tests for any Qt6-specific API changes in app_chooser_model.cpp
EXPECT_TRUE(true);
}
TEST(AppChooserModelMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// TODO: Implement actual functionality tests
EXPECT_TRUE(true);
}
@@ -1,77 +0,0 @@
/**
* @file test_asm_dtc.cpp
* @brief Verhaltenstests für die generierte AssetManagement Dtc/Ftc-Schnittstelle
*
* Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus asm_service.xml
* generierten Header (Lts/Services/AssetManagement/asm_dtc.h bzw. asm_ftc.h)
* aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben.
* Zusätzlich werden die plainen DDS-Typ-Member aus asm.hpp verifiziert, auf die
* der migrierte Code (asm_dtc_impl_custom.cpp, main_handler.cpp) zugreift.
*/
#include "AssetManagement/asm_dtc.h"
#include "AssetManagement/asm_ftc.h"
#include <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates);
* beide Schnittstellen sind abstrakt.
*/
TEST(asm_dtc_Generated, DtcIsQObjectDerived)
{
static_assert(std::is_base_of<QObject, AssetManagement::Interface::Dtc>::value,
"generierter Dtc muss von QObject abgeleitet sein");
static_assert(std::is_abstract<AssetManagement::Interface::Dtc>::value,
"Dtc muss abstrakt sein");
static_assert(std::is_abstract<AssetManagement::Interface::Ftc>::value,
"Ftc muss abstrakt sein");
EXPECT_TRUE(true);
}
/**
* @test Die generierten Identifier müssen dem Service-Namensschema folgen.
*/
TEST(asm_dtc_Generated, IdentifiersMatchService)
{
EXPECT_STREQ(AssetManagement::Interface::Dtc::identifier(), "AssetManagement.Interface.Dtc");
EXPECT_STREQ(AssetManagement::Interface::Ftc::identifier(), "AssetManagement.Interface.Ftc");
}
/**
* @test Die DDS-Typen aus asm.hpp müssen plain-Member bereitstellen (rtiddsgen 7.7):
* Asset (id, name, assetTypeId, locationId, subLocation), die der migrierte
* AssetManagement-Code direkt als Felder nutzt.
*/
TEST(asm_dtc_Generated, AssetHasPlainMembers)
{
using Asset = AssetManagement::Asset;
static_assert(std::is_base_of<::Core::BaseEntity, Asset>::value,
"Asset muss von Core::BaseEntity abgeleitet sein (id/name/isUsed)");
static_assert(std::is_same<decltype(Asset{}.id), int32_t>::value,
"id muss ein plain int32_t-Member sein");
static_assert(std::is_same<decltype(Asset{}.name), std::string>::value,
"name muss ein plain std::string-Member sein");
static_assert(std::is_same<decltype(Asset{}.assetTypeId), ::AssetManagement::AssetType>::value,
"assetTypeId muss ein plain AssetType-Member sein");
static_assert(std::is_same<decltype(Asset{}.locationId), int32_t>::value,
"locationId muss ein plain int32_t-Member sein");
static_assert(std::is_same<decltype(Asset{}.subLocation), int32_t>::value,
"subLocation muss ein plain int32_t-Member sein");
EXPECT_TRUE(true);
}
/**
* @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
*/
TEST(asm_dtc_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "AssetManagement/asm_dtc.h"
#include "AssetManagement/asm_ftc.h"
EXPECT_TRUE(true);
}
@@ -1,57 +0,0 @@
/**
* @file test_asm_enums.cpp
* @brief Verhaltenstests für die generierten AssetManagement-Enumerationen
*
* Diese Tests prüfen den von rtiddsgen aus asm_enums.idl generierten Header
* (Lts/Services/AssetManagement/asm_enums.hpp) aus dem Build-Tree.
* Die Werte stammen aus asm_service.xml (MapType, ShutdownAction, AssetType).
*/
#include "Lts/Services/AssetManagement/asm_enums.hpp"
#include <gtest/gtest.h>
#include <type_traits>
/**
* @test MapType muss mit den Werten aus asm_enums.idl generiert werden.
*/
TEST(AsmEnumsTest, MapTypeValues)
{
static_assert(std::is_enum<::AssetManagement::MapType>::value,
"MapType muss aus asm_enums.hpp vorliegen");
EXPECT_EQ(static_cast<int>(::AssetManagement::MapType::Unknown), 0);
EXPECT_EQ(static_cast<int>(::AssetManagement::MapType::Topographic), 1);
EXPECT_EQ(static_cast<int>(::AssetManagement::MapType::Aerial), 2);
EXPECT_EQ(static_cast<int>(::AssetManagement::MapType::Feature), 3);
EXPECT_EQ(static_cast<int>(::AssetManagement::MapType::Elevation), 4);
EXPECT_EQ(static_cast<int>(::AssetManagement::MapType::SceneObjects), 5);
}
/**
* @test ShutdownAction muss mit den Werten aus asm_enums.idl generiert werden.
*/
TEST(AsmEnumsTest, ShutdownActionValues)
{
static_assert(std::is_enum<::AssetManagement::ShutdownAction>::value,
"ShutdownAction muss aus asm_enums.hpp vorliegen");
EXPECT_EQ(static_cast<int>(::AssetManagement::ShutdownAction::NoAction), 0);
EXPECT_EQ(static_cast<int>(::AssetManagement::ShutdownAction::Logout), 1);
EXPECT_EQ(static_cast<int>(::AssetManagement::ShutdownAction::Shutdown), 2);
EXPECT_EQ(static_cast<int>(::AssetManagement::ShutdownAction::Reboot), 3);
}
/**
* @test AssetType muss mit den Werten aus asm_enums.idl generiert werden.
*/
TEST(AsmEnumsTest, AssetTypeValues)
{
static_assert(std::is_enum<::AssetManagement::AssetType>::value,
"AssetType muss aus asm_enums.hpp vorliegen");
EXPECT_EQ(static_cast<int>(::AssetManagement::AssetType::Unknown), 0);
EXPECT_EQ(static_cast<int>(::AssetManagement::AssetType::Workstation), 1);
EXPECT_EQ(static_cast<int>(::AssetManagement::AssetType::Printer), 2);
EXPECT_EQ(static_cast<int>(::AssetManagement::AssetType::Beamer), 3);
EXPECT_EQ(static_cast<int>(::AssetManagement::AssetType::ProjectionWorkstation), 4);
EXPECT_EQ(static_cast<int>(::AssetManagement::AssetType::MobileAfterActionVehicle), 5);
EXPECT_EQ(static_cast<int>(::AssetManagement::AssetType::AdlerSAA), 6);
}
@@ -1,16 +0,0 @@
/**
* @file test_avm_dtc.cpp
* @brief Compilation test for AudioVideoManagement/avm_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "AudioVideoManagement/avm_dtc.h"
#include <gtest/gtest.h>
TEST(avm_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_avm_enums.cpp
* @brief Compilation test for AudioVideoManagement/avm_enums.hpp
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Lts/Services/AudioVideoManagement/avm_enums.hpp"
#include <gtest/gtest.h>
TEST(avm_enums_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,74 +0,0 @@
/**
* @file test_bld_dtc.cpp
* @brief Verhaltenstests für die generierte Buildings Dtc/Ftc-Schnittstelle
*
* Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus der bld_service.xml
* generierten Header (Lts/Proxies/Buildings/bld_dtc.h bzw. bld_ftc.h) aus dem
* Build-Tree. Der OFF-Stub include/Buildings/bld_dtc.h wurde entfernt, da er
* den generierten Header verschattet hat. Zusätzlich werden die plainen
* DDS-Typ-Member aus bld.hpp verifiziert (SwitchRelayRequest), die die
* migrierten Consumer (relay_info_handler, VWM) direkt als Felder nutzen.
*/
#include "Buildings/bld_dtc.h"
#include "Buildings/bld_ftc.h"
#include <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates);
* beide Schnittstellen sind abstrakt.
*/
TEST(bld_dtc_Generated, DtcIsQObjectDerived)
{
static_assert(std::is_base_of<QObject, Buildings::Interface::Dtc>::value,
"generierter Dtc muss von QObject abgeleitet sein");
static_assert(std::is_abstract<Buildings::Interface::Dtc>::value,
"Dtc muss abstrakt sein");
static_assert(std::is_abstract<Buildings::Interface::Ftc>::value,
"Ftc muss abstrakt sein");
EXPECT_TRUE(true);
}
/**
* @test Die generierten Identifier müssen dem Proxy-Namensschema folgen.
*/
TEST(bld_dtc_Generated, IdentifiersMatchProxy)
{
EXPECT_STREQ(Buildings::Interface::Dtc::identifier(), "Buildings.Interface.Dtc");
EXPECT_STREQ(Buildings::Interface::Ftc::identifier(), "Buildings.Interface.Ftc");
}
/**
* @test Die DDS-Typen aus bld.hpp müssen plain-Member bereitstellen (rtiddsgen 7.7):
* SwitchRelayRequest (buildingId/assetId/state), den relay_info_handler
* und die VWM-Steuerung als Felder nutzen.
*/
TEST(bld_dtc_Generated, SwitchRelayRequestHasPlainMembers)
{
using SwitchRelayRequest = Buildings::SwitchRelayRequest;
static_assert(std::is_same<decltype(SwitchRelayRequest{}.buildingId), int32_t>::value,
"buildingId muss ein plain int32_t-Member sein");
static_assert(std::is_same<decltype(SwitchRelayRequest{}.assetId), int32_t>::value,
"assetId muss ein plain int32_t-Member sein");
static_assert(std::is_same<decltype(SwitchRelayRequest{}.state), ::Buildings::StateSetRelay>::value,
"state muss ein plain Buildings::StateSetRelay-Member sein");
static_assert(std::is_same<decltype(SwitchRelayRequest{}.number), int32_t>::value,
"number muss ein plain int32_t-Member sein");
EXPECT_TRUE(true);
}
/**
* @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
*/
TEST(bld_dtc_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "Buildings/bld_dtc.h"
#include "Buildings/bld_ftc.h"
EXPECT_TRUE(true);
}
@@ -1,61 +0,0 @@
/**
* @file test_bld_enums.cpp
* @brief Verhaltenstests für die generierten Buildings-Enumerationen
*
* Diese Tests prüfen den von rtiddsgen aus bld_enums.idl generierten Header
* (Lts/Proxies/Buildings/bld_enums.hpp) aus dem Build-Tree. Die frühere
* CONFIGURE_FILE-Stub-Kopie (BuildingType/BuildingStatus/BuildingInfo) wurde
* entfernt, da sie bei jedem CMake-Reconfigure die echten generierten
* Enumerationen überschrieben hat.
*/
#include "Buildings/bld_enums.hpp"
#include <gtest/gtest.h>
#include <type_traits>
/**
* @test EffectTypeEnum muss mit den Werten aus bld_enums.idl generiert werden.
*/
TEST(bld_enums_Generated, EffectTypeEnumValues)
{
static_assert(std::is_enum<::Buildings::EffectTypeEnum>::value,
"EffectTypeEnum muss aus bld_enums.hpp vorliegen");
static_assert(static_cast<int32_t>(::Buildings::EffectTypeEnum::Undefined) == 0,
"EffectTypeEnum::Undefined muss 0 sein");
static_assert(static_cast<int32_t>(::Buildings::EffectTypeEnum::Relay) == 1,
"EffectTypeEnum::Relay muss 1 sein");
static_assert(static_cast<int32_t>(::Buildings::EffectTypeEnum::BackgroundSound) == 2,
"EffectTypeEnum::BackgroundSound muss 2 sein");
static_assert(static_cast<int32_t>(::Buildings::EffectTypeEnum::BsmFlash) == 3,
"EffectTypeEnum::BsmFlash muss 3 sein");
EXPECT_TRUE(true);
}
/**
* @test StateSetRelay muss mit den Werten aus bld_enums.idl generiert werden.
*/
TEST(bld_enums_Generated, StateSetRelayValues)
{
static_assert(std::is_enum<::Buildings::StateSetRelay>::value,
"StateSetRelay muss aus bld_enums.hpp vorliegen");
static_assert(static_cast<int32_t>(::Buildings::StateSetRelay::SwitchOff) == 0,
"StateSetRelay::SwitchOff muss 0 sein");
static_assert(static_cast<int32_t>(::Buildings::StateSetRelay::SwitchOn) == 1,
"StateSetRelay::SwitchOn muss 1 sein");
static_assert(static_cast<int32_t>(::Buildings::StateSetRelay::Pulse) == 2,
"StateSetRelay::Pulse muss 2 sein");
static_assert(static_cast<int32_t>(::Buildings::StateSetRelay::GetState) == 3,
"StateSetRelay::GetState muss 3 sein");
EXPECT_TRUE(true);
}
/**
* @test Include-Guard: mehrfaches Einbinden des generierten Headers ist erlaubt.
*/
TEST(bld_enums_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "Buildings/bld_enums.hpp"
EXPECT_TRUE(true);
}
@@ -1,50 +0,0 @@
/**
* @file test_build_rti_guards.cpp
* @brief Tests für BUILD_RTI conditional compilation guards
*
* Tests verify that:
* 1. BUILD_RTI is defined as 1 in the validated configuration
* 2. RTI-dependent code paths are active (BUILD_RTI=ON)
* 3. #if BUILD_RTI guards compile and evaluate correctly
*
* BUILD_RTI=ON is the only valid migration configuration — the OFF
* variant is neither built nor tested.
*/
#include <gtest/gtest.h>
// Test 1: Verify BUILD_RTI macro is defined correctly
TEST(BuildRTIGuards, MacroDefined)
{
#ifdef BUILD_RTI
// When BUILD_RTI is enabled, it should be 1
EXPECT_EQ(BUILD_RTI, 1);
#else
// When BUILD_RTI is disabled, it should be 0 or undefined
// This test passes in fallback mode
SUCCEED();
#endif
}
// Test 2: Verify RTI code paths are active in the validated configuration
TEST(BuildRTIGuards, RtiAvailableInValidatedConfig)
{
// The validated migration configuration is BUILD_RTI=ON: the RTI
// code paths must be compiled in and available.
bool rti_available = false;
#ifdef BUILD_RTI
rti_available = true;
#endif
EXPECT_TRUE(rti_available);
}
// Test 3: Verify conditional compilation doesn't break build
TEST(BuildRTIGuards, ConditionalCompilationSafe)
{
// Verify that #if BUILD_RTI guards evaluate to the active branch
int value = 0;
#if BUILD_RTI
value = 1;
#endif
EXPECT_EQ(value, 1);
}
@@ -1,16 +0,0 @@
/**
* @file test_ces_dtc.cpp
* @brief Compilation test for CentralEffectSimulation/ces_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "CentralEffectSimulation/ces_dtc.h"
#include <gtest/gtest.h>
TEST(ces_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(client_messageTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(client_messageTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(client_messageTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_cmo_dtc.cpp
* @brief Compilation test for ComponentMonitor/cmo_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "ComponentMonitor/cmo_dtc.h"
#include <gtest/gtest.h>
TEST(cmo_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,77 +0,0 @@
/**
* @file test_cod_dtc.cpp
* @brief Verhaltenstests für die generierte CodificationManagement Dtc/Ftc-Schnittstelle
*
* Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus cod_service.xml
* generierten Header (Lts/Services/CodificationManagement/cod_dtc.h bzw.
* cod_ftc.h) aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben.
* Zusätzlich werden die plainen DDS-Typ-Member aus cod.hpp verifiziert, auf die
* der migrierte Code (object_codification_data.cpp, handler_codification_data.cpp)
* zugreift.
*/
#include "CodificationManagement/cod_dtc.h"
#include "CodificationManagement/cod_ftc.h"
#include <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates);
* beide Schnittstellen sind abstrakt.
*/
TEST(cod_dtc_Generated, DtcIsQObjectDerived)
{
static_assert(std::is_base_of<QObject, CodificationManagement::Interface::Dtc>::value,
"generierter Dtc muss von QObject abgeleitet sein");
static_assert(std::is_abstract<CodificationManagement::Interface::Dtc>::value,
"Dtc muss abstrakt sein");
static_assert(std::is_abstract<CodificationManagement::Interface::Ftc>::value,
"Ftc muss abstrakt sein");
EXPECT_TRUE(true);
}
/**
* @test Die generierten Identifier müssen dem Service-Namensschema folgen.
*/
TEST(cod_dtc_Generated, IdentifiersMatchService)
{
EXPECT_STREQ(CodificationManagement::Interface::Dtc::identifier(), "CodificationManagement.Interface.Dtc");
EXPECT_STREQ(CodificationManagement::Interface::Ftc::identifier(), "CodificationManagement.Interface.Ftc");
}
/**
* @test Die DDS-Typen aus cod.hpp müssen plain-Member bereitstellen (rtiddsgen 7.7):
* CodificationData (id, isUsed, identifier, partyId), die
* object_codification_data.cpp und handler_codification_data.cpp direkt
* als Felder nutzen.
*/
TEST(cod_dtc_Generated, CodificationDataHasPlainMembers)
{
using CodificationData = CodificationManagement::CodificationData;
static_assert(std::is_base_of<::Core::BaseEntity, CodificationData>::value,
"CodificationData muss von Core::BaseEntity abgeleitet sein (id/name/isUsed)");
static_assert(std::is_same<decltype(CodificationData{}.id), int32_t>::value,
"id muss ein plain int32_t-Member sein");
static_assert(std::is_same<decltype(CodificationData{}.isUsed), bool>::value,
"isUsed muss ein plain bool-Member sein");
static_assert(std::is_same<decltype(CodificationData{}.identifier), std::string>::value,
"identifier muss ein plain std::string-Member sein");
static_assert(std::is_same<decltype(CodificationData{}.partyId), int32_t>::value,
"partyId muss ein plain int32_t-Member sein");
EXPECT_TRUE(true);
}
/**
* @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
*/
TEST(cod_dtc_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "CodificationManagement/cod_dtc.h"
#include "CodificationManagement/cod_ftc.h"
EXPECT_TRUE(true);
}
@@ -1,18 +0,0 @@
#include "Lts/Common/CodeGen/codegen_export.h"
#include <gtest/gtest.h>
TEST(codegen_exportTest, HeaderCompiles)
{
EXPECT_TRUE(true);
}
TEST(codegen_exportTest, MacrosDefined)
{
EXPECT_TRUE(true);
}
TEST(codegen_exportTest, NamespaceExists)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_core_dtc.cpp
* @brief Compilation test for Core/core_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Core/core_dtc.h"
#include <gtest/gtest.h>
TEST(core_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_core_enums.cpp
* @brief Compilation test for Core/core_enums.hpp
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Lts/DDS/Core/core_enums.hpp"
#include <gtest/gtest.h>
TEST(core_enums_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_eem_dtc.cpp
* @brief Compilation test for ExerciseEventManagement/eem_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "ExerciseEventManagement/eem_dtc.h"
#include <gtest/gtest.h>
TEST(eem_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_eem_enums.cpp
* @brief Compilation test for Services/ExerciseEventManagement/eem_enums.hpp
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Lts/Services/ExerciseEventManagement/eem_enums.hpp"
#include <gtest/gtest.h>
TEST(eem_enums_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,22 +0,0 @@
/**
* @file test_egcuSimulator.cpp
* @brief CTest for egcuSimulator (Qt6 migration validation)
*/
#include <gtest/gtest.h>
// Compilation stub - verifies headers compile
TEST(egcuSimulatorTest, CompilationStub) {
EXPECT_TRUE(true);
}
// Qt6 API compatibility test
TEST(egcuSimulatorTest, Qt6ApiCompatibility) {
// Verify Qt6 network APIs are accessible
EXPECT_TRUE(true);
}
// Basic functionality test
TEST(egcuSimulatorTest, BasicFunctionality) {
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for elevation_unit_test.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(elevation_unit_testMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(elevation_unit_testMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(elevation_unit_testMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_esc_dtc.cpp
* @brief Compilation test for EffectShowClient/esc_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "EffectShowClient/esc_dtc.h"
#include <gtest/gtest.h>
TEST(esc_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_esm_dtc.cpp
* @brief Compilation test for EffectShowManagement/esm_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "EffectShowManagement/esm_dtc.h"
#include <gtest/gtest.h>
TEST(esm_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,66 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/Event.h"
#include <QtGui/QColor>
#include <QtCore/QJsonObject>
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class EventTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(EventTest, ConstructorInitializesMembers)
{
QStringList path = {QStringLiteral("actuator"), QStringLiteral("subactuator")};
QJsonObject detailData;
detailData[QStringLiteral("key")] = QStringLiteral("value");
QColor color(Qt::red);
Event event(1, 2, 1000, 2000, 3, 4, 5, path, nullptr, color, detailData);
EXPECT_EQ(event.uniqueId(), 1);
EXPECT_EQ(event.typeId(), 2);
EXPECT_EQ(event.startTime(), 1000);
EXPECT_EQ(event.endTime(), 2000);
EXPECT_EQ(event.playerId(), 3);
EXPECT_EQ(event.partyId(), 4);
EXPECT_EQ(event.equipmentId(), 5);
EXPECT_EQ(event.getActuator(), path);
EXPECT_EQ(event.getColor(), color);
}
TEST(EventTest, DurationCalculation)
{
Event event(1, 2, 1000, 3000, 0, 0, 0, QStringList(), nullptr, QColor(), QJsonObject());
qint64 duration = event.duration(true);
EXPECT_EQ(duration, 2000);
}
TEST(EventTest, VisibilityToggle)
{
Event event(1, 2, 1000, 2000, 0, 0, 0, QStringList(), nullptr, QColor(), QJsonObject());
EXPECT_TRUE(event.isVisible());
event.hide();
EXPECT_FALSE(event.isVisible());
event.show();
EXPECT_TRUE(event.isVisible());
event.setVisible(false);
EXPECT_FALSE(event.isVisible());
event.setVisible(true);
EXPECT_TRUE(event.isVisible());
}
} // namespace LtsTimelineClassic
@@ -1,52 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/EventDelegate.h"
#include <QtWidgets/QWidget>
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class EventDelegateTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(EventDelegateTest, ConstructorCreatesDelegate)
{
QWidget widget;
EventDelegate delegate(&widget);
EXPECT_NE(delegate.parent(), nullptr);
}
TEST(EventDelegateTest, SizeHintReturnsValidSize)
{
QWidget widget;
EventDelegate delegate(&widget);
QStyleOptionViewItem option;
QModelIndex index;
QSize size = delegate.sizeHint(option, index);
EXPECT_EQ(size.width(), 50);
EXPECT_EQ(size.height(), 20);
}
TEST(EventDelegateTest, SetKnownRangesStoresRanges)
{
QWidget widget;
EventDelegate delegate(&widget);
QVector<Range> ranges;
ranges.append(Range(0, 100));
ranges.append(Range(200, 300));
// setKnownRanges is a public method - we can call it
// The internal storage is private, so we just verify the call compiles and doesn't crash
EXPECT_NO_THROW(delegate.setKnownRanges(ranges));
}
} // namespace LtsTimelineClassic
@@ -1,59 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/Event.h"
#include "Lts/Common/LtsTimelineClassic/EventGraphic.h"
#include <QtGui/QPainter>
#include <QtCore/QRect>
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class EventGraphicTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(EventGraphicTest, ConstructorCreatesEventGraphic)
{
Event event(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
EventGraphic graphic(&event);
EXPECT_FALSE(graphic.isMultipleEvent());
EXPECT_EQ(graphic.eventList().size(), 1);
}
TEST(EventGraphicTest, AddEventMakesItMultiple)
{
Event event1(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
Event event2(50, 100, 50, 150, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::blue, QJsonObject());
EventGraphic graphic(&event1);
EXPECT_FALSE(graphic.isMultipleEvent());
graphic.addEvent(&event2);
EXPECT_TRUE(graphic.isMultipleEvent());
EXPECT_EQ(graphic.eventList().size(), 2);
}
TEST(EventGraphicTest, AddEventListMakesItMultiple)
{
Event event1(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
Event event2(50, 100, 50, 150, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::blue, QJsonObject());
Event event3(100, 100, 100, 200, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::green, QJsonObject());
EventGraphic graphic(&event1);
QVector<Event*> additionalEvents;
additionalEvents.append(&event2);
additionalEvents.append(&event3);
graphic.addEventList(additionalEvents);
EXPECT_TRUE(graphic.isMultipleEvent());
EXPECT_EQ(graphic.eventList().size(), 3);
}
} // namespace LtsTimelineClassic
@@ -1,69 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/Event.h"
#include "Lts/Common/LtsTimelineClassic/EventGraphic.h"
#include "Lts/Common/LtsTimelineClassic/EventList.h"
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class EventListTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(EventListTest, EventListTypedefWorks)
{
Event event1(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
Event event2(50, 100, 50, 150, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::blue, QJsonObject());
EventList list;
list.append(&event1);
list.append(&event2);
EXPECT_EQ(list.size(), 2);
EXPECT_EQ(list[0], &event1);
EXPECT_EQ(list[1], &event2);
}
TEST(EventListTest, EventListIterationWorks)
{
Event event1(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
Event event2(50, 100, 50, 150, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::blue, QJsonObject());
Event event3(100, 100, 100, 200, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::green, QJsonObject());
EventList list;
list.append(&event1);
list.append(&event2);
list.append(&event3);
int count = 0;
for (Event* event : list)
{
EXPECT_NE(event, nullptr);
count++;
}
EXPECT_EQ(count, 3);
}
TEST(EventListTest, EventGraphicListTypedefWorks)
{
Event event1(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
Event event2(50, 100, 50, 150, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::blue, QJsonObject());
EventGraphic graphic1(&event1);
EventGraphic graphic2(&event2);
EventGraphicList graphicList;
graphicList.append(&graphic1);
graphicList.append(&graphic2);
EXPECT_EQ(graphicList.size(), 2);
EXPECT_EQ(graphicList[0], &graphic1);
EXPECT_EQ(graphicList[1], &graphic2);
}
} // namespace LtsTimelineClassic
@@ -1,105 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/Event.h"
#include "Lts/Common/LtsTimelineClassic/EventGraphic.h"
#include "Lts/Common/LtsTimelineClassic/EventTools.h"
#include <QtGui/QPainter>
#include <QtGui/QPixmap>
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class EventToolsTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(EventToolsTest, FromMsecsToSecondsConvertsCorrectly)
{
qint64 result = EventTools::fromMsecsToSeconds(5000);
EXPECT_EQ(result, 5);
}
TEST(EventToolsTest, FromSecondsToMsecsConvertsCorrectly)
{
qint64 result = EventTools::fromSecondsToMsecs(5);
EXPECT_EQ(result, 5000);
}
TEST(EventToolsTest, SetValuesMakesValidWithPositiveRange)
{
EventTools::setValues(10, 100, 0, 50);
EXPECT_TRUE(EventTools::isValid());
}
TEST(EventToolsTest, GetEventPositionReturnsCorrectPosition)
{
EventTools::setValues(0, 1000, 0, 500);
EventTools::setSection(0, 1000);
int pos = EventTools::getEventPosition(500);
EXPECT_GE(pos, 0);
}
TEST(EventToolsTest, GetEventTimeReturnsCorrectTime)
{
EventTools::setValues(0, 1000, 0, 500);
EventTools::setSection(0, 1000);
qint64 time = EventTools::getEventTime(500);
EXPECT_GE(time, 0);
}
TEST(EventToolsTest, DrawMarkLinesDoesNotCrash)
{
EventTools::setValues(0, 1000, 0, 500);
EventTools::setSection(0, 1000);
Event event1(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
Event event2(500, 100, 500, 600, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::blue, QJsonObject());
EventList eventList;
eventList.append(&event1);
eventList.append(&event2);
QPixmap pixmap(800, 600);
QPainter painter(&pixmap);
EXPECT_NO_THROW(EventTools::drawMarkLines(&painter, eventList, 600));
}
TEST(EventToolsTest, DrawEventsDoesNotCrash)
{
EventTools::setValues(0, 1000, 0, 500);
EventTools::setSection(0, 1000);
Event event1(0, 100, 0, 100, 0, 0, 0, QStringList(), Event::EventPaintFunc(), Qt::red, QJsonObject());
EventGraphic graphic1(&event1);
EventGraphicList graphicList;
graphicList.append(&graphic1);
QPixmap pixmap(800, 600);
QPainter painter(&pixmap);
EXPECT_NO_THROW(EventTools::drawEvents(&painter, graphicList, 0));
}
TEST(EventToolsTest, GetAdjustedMinReturnsZeroWhenInvalid)
{
EventTools::setValues(0, 0, 0, 0);
qint64 min = EventTools::getAdjustedMin();
EXPECT_EQ(min, 0);
}
TEST(EventToolsTest, GetTimelineMinReturnsZeroWhenInvalid)
{
EventTools::setValues(0, 0, 0, 0);
qint64 min = EventTools::getTimelineMin();
EXPECT_EQ(min, 0);
}
} // namespace LtsTimelineClassic
@@ -1,90 +0,0 @@
/**
* @file test_evl_dtc.cpp
* @brief Verhaltenstests für die generierte Evaluations Dtc/Ftc-Schnittstelle
*
* Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus evl_service.xml
* generierten Header (Lts/Services/Evaluations/evl_dtc.h bzw. evl_ftc.h)
* aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben.
* Zusätzlich werden die plainen DDS-Typ-Member aus evl.hpp verifiziert, auf die
* der migrierte Code (handler_comment.cpp, handler_san_nine_liner.cpp,
* object_comment.cpp, object_san_nine_liner.cpp usw.) zugreift.
*/
#include "Evaluations/evl_dtc.h"
#include "Evaluations/evl_ftc.h"
#include <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates);
* beide Schnittstellen sind abstrakt.
*/
TEST(evl_dtc_Generated, DtcIsQObjectDerived)
{
static_assert(std::is_base_of<QObject, Evaluations::Interface::Dtc>::value,
"generierter Dtc muss von QObject abgeleitet sein");
static_assert(std::is_abstract<Evaluations::Interface::Dtc>::value,
"Dtc muss abstrakt sein");
static_assert(std::is_abstract<Evaluations::Interface::Ftc>::value,
"Ftc muss abstrakt sein");
EXPECT_TRUE(true);
}
/**
* @test Die generierten Identifier müssen dem Service-Namensschema folgen.
*/
TEST(evl_dtc_Generated, IdentifiersMatchService)
{
EXPECT_STREQ(Evaluations::Interface::Dtc::identifier(), "Evaluations.Interface.Dtc");
EXPECT_STREQ(Evaluations::Interface::Ftc::identifier(), "Evaluations.Interface.Ftc");
}
/**
* @test Die DDS-Typen aus evl.hpp müssen plain-Member bereitstellen (rtiddsgen 7.7):
* EvaluationComment (optionaler receiverOperatorId, text), EvaluationCriterium
* und SanNineLiner (line1_position als GeoPosition2D mit plain lon/lat), die
* der migrierte Evaluations-Code direkt als Felder nutzt.
*/
TEST(evl_dtc_Generated, EvaluationTypesHavePlainMembers)
{
using EvaluationComment = Evaluations::EvaluationComment;
using EvaluationCriterium = Evaluations::EvaluationCriterium;
using SanNineLiner = Evaluations::SanNineLiner;
static_assert(std::is_same<decltype(EvaluationComment{}.receiverOperatorId),
::omg::types::optional<int32_t>>::value,
"receiverOperatorId muss ein omg::types::optional<int32_t>-Member sein");
static_assert(std::is_same<decltype(EvaluationComment{}.text), std::string>::value,
"text muss ein plain std::string-Member sein");
static_assert(std::is_same<decltype(EvaluationComment{}.elementId), int32_t>::value,
"elementId muss ein plain int32_t-Member sein");
static_assert(std::is_same<decltype(EvaluationCriterium{}.name), std::string>::value,
"EvaluationCriterium::name muss ein plain std::string-Member sein");
static_assert(std::is_same<decltype(SanNineLiner{}.line1_position), ::Core::GeoPosition2D>::value,
"line1_position muss ein plain Core::GeoPosition2D-Member sein");
static_assert(std::is_same<decltype(SanNineLiner{}.lines), std::string>::value,
"lines muss ein plain std::string-Member sein");
// GeoPosition2D bringt plain lon/lat-Member mit (kein Getter/Setter mehr).
static_assert(std::is_same<decltype(::Core::GeoPosition2D{}.lon), double>::value,
"GeoPosition2D::lon muss ein plain double-Member sein");
static_assert(std::is_same<decltype(::Core::GeoPosition2D{}.lat), double>::value,
"GeoPosition2D::lat muss ein plain double-Member sein");
EXPECT_TRUE(true);
}
/**
* @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
*/
TEST(evl_dtc_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "Evaluations/evl_dtc.h"
#include "Evaluations/evl_ftc.h"
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_exm_dtc.cpp
* @brief Compilation test for ExerciseManagement/exm_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "ExerciseManagement/exm_dtc.h"
#include <gtest/gtest.h>
TEST(exm_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_exm_enums.cpp
* @brief Compilation test for ExerciseManagement/exm_enums.hpp
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Lts/Services/ExerciseManagement/exm_enums.hpp"
#include <gtest/gtest.h>
TEST(exm_enums_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,146 +0,0 @@
/**
* @file test_export_headers.cpp
* @brief Tests für Export Header Guards
*
* Tests verify that export headers exist and can be included without errors.
* Note: Export macros are defined via CMake target_compile_definitions,
* so we test header existence and structure rather than macro expansion.
*
* All export headers are generated into the build tree. The build directory
* is passed in via the MIGRATION_TEST_BUILD_DIR compile definition (its
* name is not stable across pipeline stages), and only headers of targets
* that are part of the validated build are checked.
*/
#include <fstream>
#include <gtest/gtest.h>
#include <string>
#include <vector>
#ifndef MIGRATION_TEST_BUILD_DIR
#error "MIGRATION_TEST_BUILD_DIR must be defined by tests/CMakeLists.txt"
#endif
namespace
{
const std::string kBuildDir = MIGRATION_TEST_BUILD_DIR;
// Helper to check if file exists and is readable
bool fileExists(const std::string& path)
{
std::ifstream file(path);
return file.good();
}
// Helper to read file content
std::string readFile(const std::string& path)
{
std::ifstream file(path);
if (!file.is_open())
{
return "";
}
return std::string((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
}
} // namespace
// Test 1: nglwidgets_export.h exists
TEST(ExportHeaders, NglWidgetsExportExists)
{
std::string path = kBuildDir + "/Z/src/nglwidgets/nglwidgets_export.h";
EXPECT_TRUE(fileExists(path)) << "Export header not found: " << path;
}
// Test 2: qtsingleapplication_export.h exists
TEST(ExportHeaders, QtSingleApplicationExportExists)
{
std::string path = kBuildDir + "/Z/src/QtSingleApplication/qtsingleapplication_export.h";
EXPECT_TRUE(fileExists(path)) << "Export header not found: " << path;
}
// Test 3: ltssessiondata_export.h exists
TEST(ExportHeaders, LtsSessionDataExportExists)
{
std::string path = kBuildDir + "/Lts/Common/LtsSession/ltssessiondata_export.h";
EXPECT_TRUE(fileExists(path)) << "Export header not found: " << path;
}
// Test 4: ddsconnector_export.h exists
TEST(ExportHeaders, DdsConnectorExportExists)
{
// This originally asserted svcgmpserver_export.h (GuezMinelayerProcessing).
// That sibling service is not part of this migration and is not built by
// the validation pipeline, so its export header is never generated.
// ddsconnector is a core dependency of the migrated FileManagement and
// FilterManagement services and part of the validated build.
std::string path = kBuildDir + "/Lts/DDS/DDSConnector/ddsconnector_export.h";
EXPECT_TRUE(fileExists(path)) << "Export header not found: " << path;
}
// Test 5: Export headers have proper include guards
TEST(ExportHeaders, HaveIncludeGuards)
{
std::vector<std::string> headers = {
kBuildDir + "/Z/src/nglwidgets/nglwidgets_export.h",
kBuildDir + "/Z/src/QtSingleApplication/qtsingleapplication_export.h",
kBuildDir + "/Lts/Common/LtsSession/ltssessiondata_export.h",
kBuildDir + "/Lts/DDS/DDSConnector/ddsconnector_export.h"};
for (const auto& header : headers)
{
std::string content = readFile(header);
EXPECT_FALSE(content.empty()) << "Export header not found: " << header;
if (!content.empty())
{
// Check for #ifndef guard
bool hasIfndef = content.find("#ifndef") != std::string::npos;
bool hasDefine = content.find("#define") != std::string::npos;
bool hasEndif = content.find("#endif") != std::string::npos;
EXPECT_TRUE(hasIfndef && hasDefine && hasEndif) << "Header " << header << " missing proper include guards";
}
}
}
// Test 6: Export macros follow naming convention
TEST(ExportHeaders, MacroNamingConvention)
{
// Check that export headers follow CMake naming convention:
// <PREFIX>_EXPORT_H guard for target <prefix>
std::string connectorPath = kBuildDir + "/Lts/DDS/DDSConnector/ddsconnector_export.h";
std::string content = readFile(connectorPath);
EXPECT_FALSE(content.empty()) << "Export header not found: " << connectorPath;
if (!content.empty())
{
// Should have DDSCONNECTOR_EXPORT_H guard
bool hasCorrectGuard = content.find("#ifndef DDSCONNECTOR_EXPORT_H") != std::string::npos;
EXPECT_TRUE(hasCorrectGuard) << "ddsconnector_export.h should use DDSCONNECTOR_EXPORT_H guard";
}
}
// Test 7: Export headers define both EXPORT and NO_EXPORT macros
TEST(ExportHeaders, ExportAndNoExportMacros)
{
std::vector<std::pair<std::string, std::string>> expectedMacros = {
{kBuildDir + "/Lts/DDS/DDSConnector/ddsconnector_export.h", "DDSCONNECTOR"},
{kBuildDir + "/Lts/DDS/FTS/ddsfts_export.h", "DDSFTS"},
{kBuildDir + "/Lts/DDS/Core/ddscore_export.h", "DDSCORE"},
// Target LtsSessionData uppercases to LTSSESSIONDATA (LTS + SESSIONDATA),
// matching the macros generated in ltssessiondata_export.h.
{kBuildDir + "/Lts/Common/LtsSession/ltssessiondata_export.h", "LTSSESSIONDATA"}};
for (const auto& [header, prefix] : expectedMacros)
{
std::string content = readFile(header);
EXPECT_FALSE(content.empty()) << "Export header not found: " << header;
if (!content.empty())
{
bool hasExport = content.find(prefix + "_EXPORT") != std::string::npos;
bool hasNoExport = content.find(prefix + "_NO_EXPORT") != std::string::npos;
EXPECT_TRUE(hasExport) << header << " should define " << prefix << "_EXPORT";
EXPECT_TRUE(hasNoExport) << header << " should define " << prefix << "_NO_EXPORT";
}
}
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(filter_background_widgetTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(filter_background_widgetTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(filter_background_widgetTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(filter_track_widgetTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(filter_track_widgetTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(filter_track_widgetTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,75 +0,0 @@
/**
* @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<int>), die
* flm_db_impl_custom.cpp für Status-Vergleich und SQL-Bind verwendet.
*/
#include <FileManagement/flm_db_impl_custom.h>
#include <gtest/gtest.h>
#include <type_traits>
/**
* @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<FileManagement::DatabaseInterfaceImplCustom>::value,
"DatabaseInterfaceImplCustom muss final sein");
static_assert(std::is_base_of<FileManagement::DatabaseInterfaceImpl,
FileManagement::DatabaseInterfaceImplCustom>::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<FileManagement::DatabaseInterfaceImpl>::value,
"generierte Basis muss abstrakt sein");
static_assert(!std::is_abstract<FileManagement::DatabaseInterfaceImplCustom>::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<UpdateStatus,
decltype(&FileManagement::DatabaseInterfaceImplCustom::updateStatus)>::value,
"updateStatus-Signatur muss (int, const FileStatus&, int) sein");
static_assert(std::is_same<SetUsedBy,
decltype(&FileManagement::DatabaseInterfaceImplCustom::setUsedBy)>::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<int>(status) an :st —
* die Enum-Werte sind der Vertrag der geänderten Logik.
*/
TEST(flm_db_impl_custom, StatusEnumValuesMatchSqlBindConversion)
{
EXPECT_EQ(static_cast<int>(FileManagement::FileStatus::Valid), 0);
EXPECT_EQ(static_cast<int>(FileManagement::FileStatus::Deleted), 1);
}
@@ -1,60 +0,0 @@
/**
* @file test_flm_dtc.cpp
* @brief Verhaltenstests für die generierte FileManagement Dtc/Ftc-Schnittstelle
*
* Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus flm_service.xml
* generierten Header (Lts/Services/FileManagement/flm_dtc.h bzw. flm_ftc.h)
* aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben.
*/
#include "FileManagement/flm_dtc.h"
#include "FileManagement/flm_ftc.h"
#include <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates).
*/
TEST(flm_dtc_Generated, DtcIsQObjectDerived)
{
static_assert(std::is_base_of<QObject, FileManagement::Interface::Dtc>::value,
"generierter Dtc muss von QObject abgeleitet sein");
EXPECT_TRUE(true);
}
/**
* @test Die generierten Identifier müssen dem Service-Namensschema folgen.
*/
TEST(flm_dtc_Generated, IdentifiersMatchService)
{
EXPECT_STREQ(FileManagement::Interface::Dtc::identifier(), "FileManagement.Interface.Dtc");
EXPECT_STREQ(FileManagement::Interface::Ftc::identifier(), "FileManagement.Interface.Ftc");
}
/**
* @test Die Schnittstellen sind abstrakt und stellen die Topic-Zugriffe aus
* flm_service.xml bereit (Folder, FileContent, ...).
*/
TEST(flm_dtc_Generated, TopicInterfacesAreAbstract)
{
using DtcType = FileManagement::Interface::Dtc;
using FtcType = FileManagement::Interface::Ftc;
static_assert(std::is_abstract<DtcType>::value, "Dtc muss abstrakt sein");
static_assert(std::is_abstract<FtcType>::value, "Ftc muss abstrakt sein");
EXPECT_TRUE(true);
}
/**
* @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
*/
TEST(flm_dtc_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "FileManagement/flm_dtc.h"
#include "FileManagement/flm_ftc.h"
EXPECT_TRUE(true);
}
@@ -1,63 +0,0 @@
/**
* @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 <FileManagement/flm_dtc_impl_custom.h>
#include <gtest/gtest.h>
#include <type_traits>
/**
* @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<FileManagement::Interface::DtcImplCustom>::value,
"DtcImplCustom muss final sein");
static_assert(std::is_base_of<FileManagement::Interface::DtcImpl,
FileManagement::Interface::DtcImplCustom>::value,
"DtcImplCustom muss von Interface::DtcImpl erben");
static_assert(std::is_base_of<QObject, FileManagement::Interface::DtcImplCustom>::value,
"Q_OBJECT erfordert eine QObject-Basis");
SUCCEED();
}
/**
* @test Der Konstruktor muss den shared_ptr<DDSConnector::DdsConnector> aus
* der generierten DtcImpl-Basis durchreichen (inherited ctor).
*/
TEST(flm_dtc_impl_custom, ConstructorTakesDdsConnector)
{
static_assert(
std::is_constructible<FileManagement::Interface::DtcImplCustom,
const std::shared_ptr<DDSConnector::DdsConnector> &>::value,
"DtcImplCustom muss aus const std::shared_ptr<DdsConnector>& 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<QString, decltype(std::declval<const DtcImplCustom &>().getExerciseFolderName(1))>::value,
"getExerciseFolderName muss const QString(int) sein");
static_assert(std::is_same<QString, decltype(std::declval<const DtcImplCustom &>().getPartyFolderName(1))>::value,
"getPartyFolderName muss const QString(int) sein");
static_assert(std::is_same<QString, decltype(std::declval<const DtcImplCustom &>().getPhaseFolderName(1))>::value,
"getPhaseFolderName muss const QString(int) sein");
SUCCEED();
}
@@ -1,58 +0,0 @@
/**
* @file test_flm_enums.cpp
* @brief Verhaltenstests für die aus flm_service.xml generierten Enums
*
* Diese Tests prüfen die Enum-Werte im generierten Header
* (Lts/Services/FileManagement/flm_enums.hpp aus flm_enums.idl via rtiddsgen)
* gegen die Definitionen in flm_service.xml. rtiddsgen 7.7 generiert
* enum class; Stub-Werte (z. B. FileStatus mit fünf Einträgen) fallen damit auf.
*/
#include "Lts/Services/FileManagement/flm_enums.hpp"
#include <gtest/gtest.h>
/**
* @test FileStatus: laut flm_service.xml gilt Valid = 0 und Deleted = 1.
*/
TEST(flm_enums_Generated, FileStatusValues)
{
EXPECT_EQ(static_cast<int>(FileManagement::FileStatus::Valid), 0);
EXPECT_EQ(static_cast<int>(FileManagement::FileStatus::Deleted), 1);
}
/**
* @test FileType: Stichproben aus der Definition in flm_service.xml
* (Unknown = 0, Pdf = 3, AdlerJson = 19).
*/
TEST(flm_enums_Generated, FileTypeValues)
{
EXPECT_EQ(static_cast<int>(FileManagement::FileType::Unknown), 0);
EXPECT_EQ(static_cast<int>(FileManagement::FileType::Pdf), 3);
EXPECT_EQ(static_cast<int>(FileManagement::FileType::AdlerJson), 19);
}
/**
* @test FileCategory und MainFolder: Werte aus flm_service.xml
* (Global = 1, Exercise = 2, User = 3 bzw. GlobalDocuments = 1, ...).
*/
TEST(flm_enums_Generated, FileCategoryAndMainFolderValues)
{
EXPECT_EQ(static_cast<int>(FileManagement::FileCategory::Global), 1);
EXPECT_EQ(static_cast<int>(FileManagement::FileCategory::Exercise), 2);
EXPECT_EQ(static_cast<int>(FileManagement::FileCategory::User), 3);
EXPECT_EQ(static_cast<int>(FileManagement::MainFolder::GlobalDocuments), 1);
EXPECT_EQ(static_cast<int>(FileManagement::MainFolder::ExerciseDocuments), 2);
EXPECT_EQ(static_cast<int>(FileManagement::MainFolder::UserDocuments), 3);
}
/**
* @test Include-Guard: mehrfaches Einbinden des generierten Headers ist erlaubt.
*/
TEST(flm_enums_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "Lts/Services/FileManagement/flm_enums.hpp"
EXPECT_TRUE(true);
}
@@ -1,70 +0,0 @@
/**
* @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 <FileManagement/flm_ftc.h>
#include <FileManagement/flm_dtc.h>
#include <FileManagement/flm_db.h>
#include <FileManagement/flm_db_impl_custom.h>
#include <FileManagement/flm_ftc_types.h>
#include <DDS/DDSConnector/dds_connector.h>
#include <FileManagement/logger.h>
#include <ngldb/db_service_handler.h>
#include <gtest/gtest.h>
#include <type_traits>
/**
* @test flm_tests.h typedef'iert DbHandler = NGLDB::DbServiceHandler<DatabaseInterface>
* — diese Instanziierung muss mit dem generierten DatabaseInterface
* kompilieren (Template vollständig instanziierbar).
*/
TEST(flm_tests, DbHandlerInstantiatesWithGeneratedDatabaseInterface)
{
using DbHandler = NGLDB::DbServiceHandler<FileManagement::DatabaseInterface>;
static_assert(std::is_class<DbHandler>::value,
"NGLDB::DbServiceHandler<FileManagement::DatabaseInterface> muss eine Klasse sein");
SUCCEED();
}
/**
* @test FlmTests erbt (protected) von genau diesen sechs Ftc-ReplyHandlern —
* sie müssen über <FileManagement/flm_ftc.h> vollständig vorliegen.
*/
TEST(flm_tests, FtcReplyHandlerBasesAreComplete)
{
using namespace FileManagement::Interface;
static_assert(std::is_class<Ftc::FolderModifyReplyHandler>::value, "FolderModifyReplyHandler fehlt");
static_assert(std::is_class<Ftc::FolderRemoveReplyHandler>::value, "FolderRemoveReplyHandler fehlt");
static_assert(std::is_class<Ftc::FileContentModifyReplyHandler>::value, "FileContentModifyReplyHandler fehlt");
static_assert(std::is_class<Ftc::FileContentRemoveReplyHandler>::value, "FileContentRemoveReplyHandler fehlt");
static_assert(std::is_class<Ftc::FileContentExportReplyHandler>::value, "FileContentExportReplyHandler fehlt");
static_assert(std::is_class<Ftc::GetFileContentDataReplyHandler>::value, "GetFileContentDataReplyHandler fehlt");
SUCCEED();
}
/**
* @test Der von FlmTests::init verwendete Dtc muss die Factory-Methode
* create(const std::shared_ptr<DdsConnector>&) bereitstellen.
*/
TEST(flm_tests, DtcCreateFactorySignature)
{
static_assert(
std::is_same<std::shared_ptr<FileManagement::Interface::Dtc> (*)(
const std::shared_ptr<DDSConnector::DdsConnector> &),
decltype(&FileManagement::Interface::Dtc::create)>::value,
"Dtc::create muss (const std::shared_ptr<DdsConnector>&) -> shared_ptr<Dtc> sein");
SUCCEED();
}
@@ -1,60 +0,0 @@
/**
* @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 <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @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<QObject, FilterManagement::Interface::Dtc>::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<DtcType>::value, "Dtc muss abstrakt sein");
static_assert(std::is_abstract<FtcType>::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);
}
@@ -1,32 +0,0 @@
/**
* @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 <gtest/gtest.h>
/**
* @test DummyEnum: laut flt_service.xml gilt val1 = 1 und val2 = 2.
*/
TEST(flt_enums_Generated, DummyEnumValues)
{
EXPECT_EQ(static_cast<int>(FilterManagement::DummyEnum::val1), 1);
EXPECT_EQ(static_cast<int>(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);
}
@@ -1,16 +0,0 @@
/**
* @file test_generic_dtc.cpp
* @brief Compilation test for DDS/DTC/generic_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "DDS/DTC/generic_dtc.h"
#include <gtest/gtest.h>
TEST(generic_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,73 +0,0 @@
/**
* @file test_gim_dtc.cpp
* @brief Verhaltenstests für die generierte GuezIedManagement Dtc/Ftc-Schnittstelle
*
* Diese Tests prüfen den von CODEGEN_CLIENT_TOPICS_IFC aus gim_service.xml
* generierten Header (Lts/Services/GuezIedManagement/gim_dtc.h bzw. gim_ftc.h)
* aus dem Build-Tree. Es darf keinen Stub-Header im Quellbaum geben.
* Zusätzlich werden die plainen DDS-Typ-Member aus gim.hpp verifiziert, auf die
* der migrierte Code (gim_dtc_impl_custom.cpp) zugreift.
*/
#include "GuezIedManagement/gim_dtc.h"
#include "GuezIedManagement/gim_ftc.h"
#include <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates);
* beide Schnittstellen sind abstrakt.
*/
TEST(gim_dtc_Generated, DtcIsQObjectDerived)
{
static_assert(std::is_base_of<QObject, GuezIedManagement::Interface::Dtc>::value,
"generierter Dtc muss von QObject abgeleitet sein");
static_assert(std::is_abstract<GuezIedManagement::Interface::Dtc>::value,
"Dtc muss abstrakt sein");
static_assert(std::is_abstract<GuezIedManagement::Interface::Ftc>::value,
"Ftc muss abstrakt sein");
EXPECT_TRUE(true);
}
/**
* @test Die generierten Identifier müssen dem Service-Namensschema folgen.
*/
TEST(gim_dtc_Generated, IdentifiersMatchService)
{
EXPECT_STREQ(GuezIedManagement::Interface::Dtc::identifier(), "GuezIedManagement.Interface.Dtc");
EXPECT_STREQ(GuezIedManagement::Interface::Ftc::identifier(), "GuezIedManagement.Interface.Ftc");
}
/**
* @test Die DDS-Typen aus gim.hpp müssen plain-Member bereitstellen (rtiddsgen 7.7):
* Ied (equipmentNumber, type, symbol), die gim_dtc_impl_custom.cpp direkt
* als Felder nutzt (ied.equipmentNumber == equipmentNumber).
*/
TEST(gim_dtc_Generated, IedHasPlainMembers)
{
using Ied = GuezIedManagement::Ied;
static_assert(std::is_base_of<::Core::BaseEntityWithSampleTime, Ied>::value,
"Ied muss von Core::BaseEntityWithSampleTime abgeleitet sein");
static_assert(std::is_same<decltype(Ied{}.equipmentNumber), int32_t>::value,
"equipmentNumber muss ein plain int32_t-Member sein");
static_assert(std::is_same<decltype(Ied{}.type), ::GuezIedManagement::IedType>::value,
"type muss ein plain IedType-Member sein");
static_assert(std::is_same<decltype(Ied{}.symbol), std::string>::value,
"symbol muss ein plain std::string-Member sein");
EXPECT_TRUE(true);
}
/**
* @test Include-Guard: mehrfaches Einbinden der generierten Header ist erlaubt.
*/
TEST(gim_dtc_Generated, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
#include "GuezIedManagement/gim_dtc.h"
#include "GuezIedManagement/gim_ftc.h"
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_gna_dtc.cpp
* @brief Compilation test for GuezNasat/gna_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "GuezNasat/gna_dtc.h"
#include <gtest/gtest.h>
TEST(gna_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(indicatorTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(indicatorTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(indicatorTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,92 +0,0 @@
/**
* @file test_ism_dtc.cpp
* @brief Verhaltenstests für die generierte InfrastructureManagement Dtc/Ftc-Schnittstelle
*
* 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 "InfrastructureManagement/ism_dtc.h"
#include "InfrastructureManagement/ism_ftc.h"
#include <gtest/gtest.h>
#include <QObject>
#include <type_traits>
/**
* @test Der generierte Dtc muss von QObject abgeleitet sein (Signale für Topic-Updates);
* beide Schnittstellen sind abstrakt.
*/
TEST(ism_dtc_Generated, DtcIsQObjectDerived)
{
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);
}
@@ -1,16 +0,0 @@
/**
* @file test_ism_enums.cpp
* @brief Compilation test for InfrastructureManagement/ism_enums.hpp
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Lts/Services/InfrastructureManagement/ism_enums.hpp"
#include <gtest/gtest.h>
TEST(ism_enums_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,44 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/Item.h"
#include <QtWidgets/QWidget>
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class ItemTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(ItemTest, HeaderCompilesAndLinks)
{
// Verify header compiles without errors
EXPECT_TRUE(true);
}
TEST(ItemTest, CanInstantiateItem)
{
// Basic instantiation test
Item item(QStringLiteral("TestItem"), QStringLiteral("test-id"));
EXPECT_EQ(item.getName(), QStringLiteral("TestItem"));
EXPECT_EQ(item.getIdentifier(), QStringLiteral("test-id"));
}
TEST(ItemTest, ItemHasValidState)
{
Item parent(QStringLiteral("Parent"));
Item child(QStringLiteral("Child"));
// Test parent-child relationship
child.setParent(&parent);
EXPECT_EQ(child.getParent(), &parent);
// Test child count
EXPECT_EQ(parent.childCount(), 0);
}
} // namespace LtsTimelineClassic
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(json_keys_headerTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(json_keys_headerTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(json_keys_headerTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,39 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/LineMap.h"
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class LineMapTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(LineMapTest, CreateEmptyLineMap)
{
LineMap lineMap;
EXPECT_TRUE(lineMap.isEmpty());
}
TEST(LineMapTest, InsertAndRetrieveValue)
{
LineMap lineMap;
lineMap.insert(1, 1000);
EXPECT_EQ(lineMap.value(1), 1000);
}
TEST(LineMapTest, ContainsKeyAfterInsert)
{
LineMap lineMap;
lineMap.insert(5, 5000);
EXPECT_TRUE(lineMap.contains(5));
EXPECT_FALSE(lineMap.contains(3));
}
} // namespace LtsTimelineClassic
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for logger.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(loggerMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(loggerMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(loggerMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for logout_info_dialog.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(logout_info_dialogMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(logout_info_dialogMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(logout_info_dialogMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lonlat2mgrs.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lonlat2mgrsMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lonlat2mgrsMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lonlat2mgrsMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,56 +0,0 @@
#include "Lts/Common/LtsAppDescriptor/lts_app_descriptor.h"
#include <QtCore/QJsonArray>
#include <QtCore/QJsonObject>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtTest/QtTest>
namespace LtsAppDescriptor
{
class TestLtsAppDescriptor : public QObject
{
Q_OBJECT
private slots:
void testPluginInfoCreation();
void testPluginInfoFlagOperations();
void testAppDescriptionDefaultConstruction();
};
void TestLtsAppDescriptor::testPluginInfoCreation()
{
PluginInfo pluginInfo;
pluginInfo.iid = QStringLiteral("test.plugin.iid");
pluginInfo.type = PluginInfo::PluginType::GUI;
pluginInfo.flags = PluginInfo::Flag::UNKNOWN;
QCOMPARE(pluginInfo.iid, QStringLiteral("test.plugin.iid"));
QCOMPARE(pluginInfo.type, PluginInfo::PluginType::GUI);
}
void TestLtsAppDescriptor::testPluginInfoFlagOperations()
{
PluginInfo pluginInfo;
pluginInfo.flags = PluginInfo::Flag::UNKNOWN;
pluginInfo.flags |= PluginInfo::Flag::ACTIONS;
QVERIFY(pluginInfo.flags & PluginInfo::Flag::ACTIONS);
pluginInfo.flags |= PluginInfo::Flag::MAIN;
QVERIFY(pluginInfo.flags & PluginInfo::Flag::ACTIONS);
QVERIFY(pluginInfo.flags & PluginInfo::Flag::MAIN);
}
void TestLtsAppDescriptor::testAppDescriptionDefaultConstruction()
{
AppDescription appDesc;
QVERIFY(appDesc.pluginInfos.isEmpty());
QVERIFY(appDesc.appName.isEmpty());
}
} // namespace LtsAppDescriptor
QTEST_MAIN(LtsAppDescriptor::TestLtsAppDescriptor)
#include "test_lts_app_descriptor.moc"
@@ -1,38 +0,0 @@
#include "lts_app_descriptor_editor.h"
#include <QtWidgets/QApplication>
#include <QtTest/QtTest>
class TestLtsAppDescriptorEditor : public QObject
{
Q_OBJECT
private slots:
void testEditorConstruction();
void testEditorDestruction();
void testEditorInitialState();
};
void TestLtsAppDescriptorEditor::testEditorConstruction()
{
// Create editor widget - requires QApplication for QWidget
LtsAppDescriptorEditor editor;
QVERIFY(!editor.windowTitle().isEmpty() || editor.windowTitle().isEmpty()); // Basic sanity check
}
void TestLtsAppDescriptorEditor::testEditorDestruction()
{
// Test that destructor doesn't crash
auto* editor = new LtsAppDescriptorEditor();
delete editor;
}
void TestLtsAppDescriptorEditor::testEditorInitialState()
{
LtsAppDescriptorEditor editor;
// Editor should start in a clean state
QVERIFY(true); // Placeholder for actual state checks
}
QTEST_MAIN(TestLtsAppDescriptorEditor)
#include "test_lts_app_descriptor_editor.moc"
@@ -1,36 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_app_manager.cpp migration validation
// Actual implementation tests should be added based on lts_app_manager.cpp functionality
namespace Lts
{
namespace Common
{
// Forward declarations to verify compilation
class LtsAppManager;
} // namespace Common
} // namespace Lts
TEST(LtsAppManagerMigrationTest, CompilationStub)
{
// Verify that lts_app_manager.cpp compiles and links correctly after Qt6 migration
// TODO: Add actual tests for LtsAppManager functionality
EXPECT_TRUE(true);
}
TEST(LtsAppManagerMigrationTest, Qt6ApiCompatibility)
{
// Verify Qt6 API compatibility
// TODO: Add tests for any Qt6-specific API changes in lts_app_manager.cpp
EXPECT_TRUE(true);
}
TEST(LtsAppManagerMigrationTest, BasicFunctionality)
{
// Basic functionality test placeholder
// TODO: Implement actual functionality tests
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_comport_querry_headerTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_comport_querry_headerTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_comport_querry_headerTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_coord_trans.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_coord_transMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_transMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_transMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_coord_trans_unit_test.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_coord_trans_unit_testMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_trans_unit_testMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_trans_unit_testMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,39 +0,0 @@
#include <gtest/gtest.h>
// Compile-level regression test for the LtsCoordinate migration.
//
// lts_coord_vector.h includes the export header generated by
// NGL_ADD_LIBRARY2 for target LtsCoordinate as
// <LtsCoordinate/ltscoordinate_export.h> (same form as the qt5 legacy).
// The build-tree location (build4/Lts/Common/LtsCoordinate) is reachable
// for consumers via the PUBLIC binary-dir include of LtsCoordinate and of
// the sibling NGL_ADD_LIBRARY2 targets under Lts/Common. A bare quoted
// #include "ltscoordinate_export.h" only resolved inside the LtsCoordinate
// target itself and broke every consumer (svcIsmClient via
// ism_dtc_impl_custom_p.h), so this TU must keep including the header the
// same way consumers do.
#include <LtsCoordinate/lts_coord_vector.h>
#ifndef LTSCOORDINATE_EXPORT
#error "ltscoordinate_export.h was not resolved; lts_coord_vector.h include regressed"
#endif
#include <type_traits>
static_assert(std::is_class<LtsCoordTrans::LtsCoordVector>::value,
"LtsCoordVector must be declared by lts_coord_vector.h");
TEST(lts_coord_vectorMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_vectorMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_vectorMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
Loaded 100 of 210 files, more files were not shown because too many files have changed in this diff. Show more