Removes mistyped target test folder from repo

This commit is contained in:
torsten committed 2026-08-19 21:20:12 +02:00
1 parent 13c341c7c7
commit 19ab996be2
180 files changed
-5259

No files matched your search

@@ -1,72 +0,0 @@
# 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)
find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets Test)
# 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()
# Nur bauen wenn BUILD_TESTING aktiviert ist
if(BUILD_TESTING)
# 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})
add_executable(migration_tests ${EXISTING_SOURCES})
target_compile_features(migration_tests PRIVATE cxx_std_23)
target_include_directories(migration_tests PRIVATE
${CMAKE_SOURCE_DIR}
${CMAKE_SOURCE_DIR}/include
${CMAKE_SOURCE_DIR}/qt6-after/qt6-migrated-legatus
${CMAKE_SOURCE_DIR}/qt6-after/qt6-migrated-legatus/include
)
# Link against Qt6 components
target_link_libraries(migration_tests PRIVATE
Qt6::Core
Qt6::Gui
Qt6::Widgets
Qt6::Test
GTest::gtest_main
)
# 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}")
else()
message(WARNING "No migration test sources found in ${CMAKE_CURRENT_SOURCE_DIR}")
endif()
endif()
@@ -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,29 +0,0 @@
#include "CppTopicGeneratorGrantlee.h"
#include <gtest/gtest.h>
// Test that CppTopicGeneratorGrantlee can be instantiated
TEST(CppTopicGeneratorGrantleeTest, CanInstantiate)
{
CodeGen::CppTopicGeneratorGrantlee generator;
// Basic instantiation test - constructor should not throw
EXPECT_NO_THROW({ CodeGen::CppTopicGeneratorGrantlee gen2; });
}
// Test that the generator has expected base class functionality
TEST(CppTopicGeneratorGrantleeTest, HasLoggerName)
{
CodeGen::CppTopicGeneratorGrantlee generator;
// The generator should have a logger name set in constructor
// This verifies the base class initialization worked correctly
EXPECT_TRUE(true); // Placeholder - actual test depends on base class API
}
// 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,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,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,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,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,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 "qt6-after/qt6-migrated-legatus/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,59 +0,0 @@
/**
* @file test_aes_dtc.cpp
* @brief Tests für AreaEffectSimulation Dtc/Ftc Stub-Header
*
* Diese Tests validieren dass die generierten DDS-Stub-Header korrekt kompilieren.
*/
#include <gtest/gtest.h>
// Include des zu testenden Headers
#include "AreaEffectSimulation/aes_dtc.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,68 +0,0 @@
/**
* @file test_aes_enums.cpp
* @brief Tests für AreaEffectSimulation Enum-Header
*
* Diese Tests validieren dass die generierten DDS-Enum-Header korrekt kompilieren.
*/
#include <gtest/gtest.h>
// Include des zu testenden Headers
#include "AreaEffectSimulation/aes_enums.hpp"
/**
* @test Test dass der Header kompiliert und Enums existieren
*/
TEST(AesEnumsTest, HeaderCompilesAndEnumsExist)
{
// Verify that enum classes are accessible
using namespace AreaEffectSimulation;
// Create enum values
SymbolAppearance appearance = SymbolAppearance::Solid;
SymbolVisibility visibility = SymbolVisibility::Visible;
EXPECT_EQ(appearance, SymbolAppearance::Solid);
EXPECT_EQ(visibility, SymbolVisibility::Visible);
// Test other enum values
EXPECT_EQ(SymbolAppearance::Dashed, static_cast<SymbolAppearance>(1));
EXPECT_EQ(SymbolAppearance::Dotted, static_cast<SymbolAppearance>(2));
EXPECT_EQ(SymbolVisibility::Hidden, static_cast<SymbolVisibility>(1));
}
/**
* @test Test dass UnitSymbolPosition struct korrekt ist
*/
TEST(AesEnumsTest, UnitSymbolPositionStruct)
{
using namespace AreaEffectSimulation;
// Test default initialization
UnitSymbolPosition pos1;
EXPECT_DOUBLE_EQ(pos1.x, 0.0);
EXPECT_DOUBLE_EQ(pos1.y, 0.0);
// Test custom initialization
UnitSymbolPosition pos2{10.5, 20.5};
EXPECT_DOUBLE_EQ(pos2.x, 10.5);
EXPECT_DOUBLE_EQ(pos2.y, 20.5);
// Test assignment
pos1 = pos2;
EXPECT_DOUBLE_EQ(pos1.x, 10.5);
EXPECT_DOUBLE_EQ(pos1.y, 20.5);
}
/**
* @test Test dass Header mehrfach inkludierbar ist (include guard)
*/
TEST(AesEnumsTest, MultipleIncludeGuard)
{
// Including the header multiple times should not cause errors
// This is implicitly tested by including it again here
#include "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 AlarmManagement/alm_dtc.h header inclusion
*
* This test verifies that the stub header can be included without errors.
* The actual Dtc/Ftc classes are generated by ddsdtc tool.
*/
#include <gtest/gtest.h>
// Include the stub header - this test ensures it compiles
#include "AlarmManagement/alm_dtc.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,40 +0,0 @@
/**
* @file test_asm_dtc.cpp
* @brief Tests for AssetManagement Dtc stub header compilation
*/
#include <gtest/gtest.h>
// Test that the header compiles and provides expected forward declarations
TEST(AsmDtcTest, HeaderCompilesSuccessfully)
{
// This test verifies that asm_dtc.h compiles without errors
// The header provides forward declarations for DDS-generated Dtc/Ftc classes
EXPECT_TRUE(true);
}
TEST(AsmDtcTest, NamespaceStructureExists)
{
// Verify that the AssetManagement namespace exists
using namespace AssetManagement;
// Verify that the Interface namespace exists within AssetManagement
using namespace AssetManagement::Interface;
// Forward declaration should be available (pointer type should compile)
Dtc* dtc_ptr = nullptr;
Ftc* ftc_ptr = nullptr;
EXPECT_EQ(dtc_ptr, nullptr);
EXPECT_EQ(ftc_ptr, nullptr);
}
TEST(AsmDtcTest, ForwardDeclarationsAreUsable)
{
// Test that forward-declared types can be used in function signatures
auto use_dtc = [](AssetManagement::Interface::Dtc* ptr) { return ptr != nullptr; };
auto use_ftc = [](AssetManagement::Interface::Ftc* ptr) { return ptr != nullptr; };
EXPECT_FALSE(use_dtc(nullptr));
EXPECT_FALSE(use_ftc(nullptr));
}
@@ -1,29 +0,0 @@
/**
* @file test_asm_enums.cpp
* @brief Tests for AssetManagement enum definitions
*/
#include "AssetManagement/asm_enums.hpp"
#include <gtest/gtest.h>
TEST(AsmEnumsTest, SymbolAppearanceEnumValues)
{
EXPECT_EQ(AssetManagement::SymbolAppearance::Solid, 0);
EXPECT_EQ(AssetManagement::SymbolAppearance::Dashed, 1);
EXPECT_EQ(AssetManagement::SymbolAppearance::Dotted, 2);
}
TEST(AsmEnumsTest, SymbolVisibilityEnumValues)
{
EXPECT_EQ(AssetManagement::SymbolVisibility::Visible, 0);
EXPECT_EQ(AssetManagement::SymbolVisibility::Hidden, 1);
}
TEST(AsmEnumsTest, UnitSymbolPositionDefaultValues)
{
AssetManagement::UnitSymbolPosition pos;
EXPECT_DOUBLE_EQ(pos.x, 0.0);
EXPECT_DOUBLE_EQ(pos.y, 0.0);
EXPECT_DOUBLE_EQ(pos.z, 0.0);
}
@@ -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 "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,16 +0,0 @@
/**
* @file test_bld_dtc.cpp
* @brief Compilation test for Buildings/bld_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Buildings/bld_dtc.h"
#include <gtest/gtest.h>
TEST(bld_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_bld_enums.cpp
* @brief Compilation test for Buildings/bld_enums.hpp
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Buildings/bld_enums.hpp"
#include <gtest/gtest.h>
TEST(bld_enums_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,49 +0,0 @@
/**
* @file test_build_rti_guards.cpp
* @brief Tests für BUILD_RTI conditional compilation guards
*
* Tests verify that:
* 1. Code compiles with BUILD_RTI=OFF (fallback mode)
* 2. RTI-dependent code is properly guarded
* 3. Non-RTI code paths work correctly
*/
#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 DDS connector compiles without RTI
TEST(BuildRTIGuards, DDSConnectorFallback)
{
// This test verifies that DDS-related headers can be included
// and basic functionality works without RTI libraries
// The actual DDS connector should have fallback implementations
bool rti_available = false;
#ifdef BUILD_RTI
rti_available = true;
#endif
EXPECT_FALSE(rti_available); // In fallback mode, RTI is not available
}
// Test 3: Verify conditional compilation doesn't break build
TEST(BuildRTIGuards, ConditionalCompilationSafe)
{
// Verify that #if BUILD_RTI guards don't cause syntax errors
int value = 0;
#if BUILD_RTI
value = 1;
#endif
// In fallback mode, value should remain 0
EXPECT_EQ(value, 0);
}
@@ -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,16 +0,0 @@
/**
* @file test_cod_dtc.cpp
* @brief Compilation test for CodificationManagement/cod_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "CodificationManagement/cod_dtc.h"
#include <gtest/gtest.h>
TEST(cod_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
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 "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 "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,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 <QColor>
#include <QJsonObject>
#include <gtest/gtest.h>
namespace LtsTimelineClassic
{
class EventTest : public ::testing::Test
{
protected:
void SetUp() override {}
void TearDown() override {}
};
TEST(EventTest, ConstructorInitializesMembers)
{
QStringList path = {"actuator", "subactuator"};
QJsonObject detailData;
detailData["key"] = "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());
qint64 duration = event.duration(true);
EXPECT_EQ(duration, 2000);
}
TEST(EventTest, VisibilityToggle)
{
Event event;
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 <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 <QPainter>
#include <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, Qt::red);
EventGraphic graphic(&event);
EXPECT_FALSE(graphic.isMultipleEvent());
EXPECT_EQ(graphic.eventList().size(), 1);
}
TEST(EventGraphicTest, AddEventMakesItMultiple)
{
Event event1(0, 100, Qt::red);
Event event2(50, 100, Qt::blue);
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, Qt::red);
Event event2(50, 100, Qt::blue);
Event event3(100, 100, Qt::green);
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, Qt::red);
Event event2(50, 100, Qt::blue);
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, Qt::red);
Event event2(50, 100, Qt::blue);
Event event3(100, 100, Qt::green);
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, Qt::red);
Event event2(50, 100, Qt::blue);
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 <QPainter>
#include <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, Qt::red);
Event event2(500, 100, Qt::blue);
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, Qt::red);
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,16 +0,0 @@
/**
* @file test_evl_dtc.cpp
* @brief Compilation test for Evaluations/evl_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "Evaluations/evl_dtc.h"
#include <gtest/gtest.h>
TEST(evl_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
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 "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,124 +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.
*/
#include <fstream>
#include <gtest/gtest.h>
#include <string>
#include <vector>
// 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>());
}
// Test 1: nglwidgets_export.h exists
TEST(ExportHeaders, NglWidgetsExportExists)
{
std::string path = "build/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 = "build/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 = "build/Lts/Common/LtsSession/ltssessiondata_export.h";
EXPECT_TRUE(fileExists(path)) << "Export header not found: " << path;
}
// Test 4: svcgmpserver_export.h exists
TEST(ExportHeaders, SvcGmpServerExportExists)
{
std::string path = "build/Lts/Services/GuezMinelayerProcessing/svcgmpserver_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 = {
"build/Z/src/nglwidgets/nglwidgets_export.h", "build/Z/src/QtSingleApplication/qtsingleapplication_export.h",
"build/Lts/Common/LtsSession/ltssessiondata_export.h", "build/Lts/Proxies/ProjectDataManagement/pdm_export.h"};
for (const auto& header : headers)
{
std::string content = readFile(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
std::string adlerPath =
"qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Plugins/AdlerJson/adler_export.h";
std::string content = readFile(adlerPath);
if (!content.empty())
{
// Should have ADLER_EXPORT_H guard
bool hasCorrectGuard = content.find("#ifndef ADLER_EXPORT_H") != std::string::npos;
EXPECT_TRUE(hasCorrectGuard) << "adler_export.h should use ADLER_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 = {
{"qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Plugins/AdlerJson/adler_export.h", "ADLER"},
{"qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Services/PresentationManagement/"
"svcprecommon_export.h",
"SVCPRECOMMON"},
{"qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Common/LtsSession/ltssessiondata_export.h",
"LTSESSIONDATA"},
{"qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Proxies/ProjectDataManagement/pdm_export.h",
"PDM"}};
for (const auto& [header, prefix] : expectedMacros)
{
std::string content = readFile(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,16 +0,0 @@
/**
* @file test_flm_dtc.cpp
* @brief Compilation test for FileManagement/flm_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "FileManagement/flm_dtc.h"
#include <gtest/gtest.h>
TEST(flm_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
/**
* @file test_flm_enums.cpp
* @brief Compilation test for FileManagement/flm_enums.hpp
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "FileManagement/flm_enums.hpp"
#include <gtest/gtest.h>
TEST(flm_enums_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
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,16 +0,0 @@
/**
* @file test_gim_dtc.cpp
* @brief Compilation test for GuezIedManagement/gim_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "GuezIedManagement/gim_dtc.h"
#include <gtest/gtest.h>
TEST(gim_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
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,16 +0,0 @@
/**
* @file test_ism_dtc.cpp
* @brief Compilation test for include/InfrastructureManagement/ism_dtc.h
*
* This test verifies that the migrated header compiles correctly with Qt6/C++23.
*/
#include "include/InfrastructureManagement/ism_dtc.h"
#include <gtest/gtest.h>
TEST(ism_dtc_Compilation, HeaderCompiles)
{
// This test verifies that the header compiles without errors
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 "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,39 +0,0 @@
#include "Lts/Common/LtsTimelineClassic/Item.h"
#include <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
QWidget parent;
Item item(&parent);
EXPECT_NO_THROW(item.update());
}
TEST(ItemTest, ItemHasValidState)
{
QWidget parent;
Item item(&parent);
// Test basic properties
EXPECT_NO_THROW(item.setGeometry(0, 0, 100, 50));
}
} // namespace LtsTimelineClassic
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(json_keys.hTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(json_keys.hTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(json_keys.hTest, 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_app_descriptor.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QString>
#include <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 = "test.plugin.iid";
pluginInfo.type = PluginInfo::PluginType::GUI;
pluginInfo.flags = PluginInfo::Flag::None;
QCOMPARE(pluginInfo.iid, QString("test.plugin.iid"));
QCOMPARE(pluginInfo.type, PluginInfo::PluginType::GUI);
}
void TestLtsAppDescriptor::testPluginInfoFlagOperations()
{
PluginInfo pluginInfo;
pluginInfo.flags = PluginInfo::Flag::None;
addOptionToPlugin(pluginInfo, PluginInfo::Flag::Mandatory);
QVERIFY(pluginInfo.flags & PluginInfo::Flag::Mandatory);
addOptionToPlugin(pluginInfo, PluginInfo::Flag::Autostart);
QVERIFY(pluginInfo.flags & PluginInfo::Flag::Mandatory);
QVERIFY(pluginInfo.flags & PluginInfo::Flag::Autostart);
}
void TestLtsAppDescriptor::testAppDescriptionDefaultConstruction()
{
AppDescription appDesc;
QVERIFY(appDesc.plugins.isEmpty());
QVERIFY(appDesc.lastErrors.isEmpty());
}
} // namespace LtsAppDescriptor
QTEST_MAIN(LtsAppDescriptor::TestLtsAppDescriptor)
#include "test_lts_app_descriptor.moc"
@@ -1,38 +0,0 @@
#include "lts_app_descriptor_editor.h"
#include <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.hTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_comport_querry.hTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_comport_querry.hTest, 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,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_coord_vector.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_coord_vectorMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_vectorMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_vectorMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_coord_widget.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_coord_widgetMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_widgetMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_widgetMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_coord_widget_test.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_coord_widget_testMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_widget_testMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_coord_widget_testMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_coordinate_unit_test.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_coordinate_unit_testMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_coordinate_unit_testMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_coordinate_unit_testMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_dummy_widget.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_dummy_widgetMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_dummy_widgetMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_dummy_widgetMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_elevation_manager.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_elevation_managerMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_elevation_managerMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_elevation_managerMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_licence.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_licenceMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_licenceMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_licenceMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_login.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_loginMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_loginMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_loginMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_magic_corner.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_magic_cornerMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_magic_cornerMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_magic_cornerMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_multi_monitor.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_multi_monitorMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitorMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitorMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,25 +0,0 @@
#include <gtest/gtest.h>
// Stub test for lts_multi_monitor_export.h.cpp migration validation
namespace Lts
{
namespace Common
{
} // namespace Common
} // namespace Lts
TEST(lts_multi_monitor_export.hMigrationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_export.hMigrationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_export.hMigrationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_multi_monitor_selector_baseTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_selector_baseTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_selector_baseTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_multi_monitor_selector_normalTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_selector_normalTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_selector_normalTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_multi_monitor_selector_wideTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_selector_wideTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_multi_monitor_selector_wideTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_notificationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_notificationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_notificationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_notification_ctlTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_notification_ctlTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_notification_ctlTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_notification_export.hTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_notification_export.hTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_notification_export.hTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_plugin_loaderTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_loaderTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_loaderTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_plugin_manager_dialogTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_manager_dialogTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_manager_dialogTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_plugin_manager_export.hTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_manager_export.hTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_manager_export.hTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_plugin_manager_widgetTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_manager_widgetTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_plugin_manager_widgetTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_projection_workstationTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_projection_workstationTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_projection_workstationTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_projection_workstation_export.hTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_projection_workstation_export.hTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_projection_workstation_export.hTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_screen_baseTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_baseTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_baseTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_screen_containerTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_containerTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_containerTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_screen_normalTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_normalTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_normalTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_screen_wideTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_wideTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_screen_wideTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
@@ -1,16 +0,0 @@
#include <gtest/gtest.h>
TEST(lts_serial_port_querryTest, CompilationStub)
{
EXPECT_TRUE(true);
}
TEST(lts_serial_port_querryTest, Qt6ApiCompatibility)
{
EXPECT_TRUE(true);
}
TEST(lts_serial_port_querryTest, BasicFunctionality)
{
EXPECT_TRUE(true);
}
Loaded 100 of 180 files, more files were not shown because too many files have changed in this diff. Show more