Apply clang-format to all test files

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

qt6-after/qt6-migrated-benchmark/tests/test_DaoGeneratorGrantlee.cpp

@@ -3,18 +3,21 @@
 // Header compilation test for DaoGeneratorGrantlee
 #include "Lts/Common/CodeGen/DaoGeneratorGrantlee.h"
 
-TEST(DaoGeneratorGrantleeTest, HeaderCompiles) {
+TEST(DaoGeneratorGrantleeTest, HeaderCompiles)
+{
     // Verify header compiles without errors
     EXPECT_TRUE(true);
 }
 
-TEST(DaoGeneratorGrantleeTest, CanInstantiate) {
+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) {
+TEST(DaoGeneratorGrantleeTest, NamespaceExists)
+{
     // Verify namespace exists
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_DatabaseGeneratorGrantlee.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/DatabaseGeneratorGrantlee.h"
 
-TEST(DatabaseGeneratorGrantleeTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(DatabaseGeneratorGrantleeTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(DatabaseGeneratorGrantleeTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(DatabaseGeneratorGrantleeTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(DatabaseGeneratorGrantleeTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(DatabaseGeneratorGrantleeTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_GeneratorGrantleeBase.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/GeneratorGrantleeBase.h"
 
-TEST(GeneratorGrantleeBaseTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(GeneratorGrantleeBaseTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(GeneratorGrantleeBaseTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(GeneratorGrantleeBaseTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(GeneratorGrantleeBaseTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(GeneratorGrantleeBaseTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_GrantleeParserSmoke.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/GrantleeParserSmoke.h"
 
-TEST(GrantleeParserSmokeTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(GrantleeParserSmokeTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(GrantleeParserSmokeTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(GrantleeParserSmokeTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(GrantleeParserSmokeTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(GrantleeParserSmokeTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_GrantleeWrappers.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/GrantleeWrappers.h"
 
-TEST(GrantleeWrappersTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(GrantleeWrappersTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(GrantleeWrappersTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(GrantleeWrappersTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(GrantleeWrappersTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(GrantleeWrappersTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_LtsCommandLineParser.cpp

@@ -3,8 +3,10 @@
 // Stub test for LtsCommandLineParser.cpp migration validation
 // Actual implementation tests should be added based on LtsCommandLineParser.cpp functionality
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 
 // Forward declarations to verify compilation
 // TODO: Add actual class/function declarations from LtsCommandLineParser
@@ -12,19 +14,22 @@ namespace Common {
 } // namespace Common
 } // namespace Lts
 
-TEST(LtsCommandLineParserMigrationTest, CompilationStub) {
+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) {
+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) {
+TEST(LtsCommandLineParserMigrationTest, BasicFunctionality)
+{
     // Basic functionality test placeholder
     // TODO: Implement actual functionality tests
     EXPECT_TRUE(true);

qt6-after/qt6-migrated-benchmark/tests/test_SqlGenerator.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/SqlGenerator.h"
 
-TEST(SqlGeneratorTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(SqlGeneratorTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(SqlGeneratorTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(SqlGeneratorTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(SqlGeneratorTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(SqlGeneratorTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_StructBuilder.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/StructBuilder.h"
 
-TEST(StructBuilderTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(StructBuilderTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(StructBuilderTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(StructBuilderTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(StructBuilderTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(StructBuilderTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_XmlReader.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/XmlReader.h"
 
-TEST(XmlReaderTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(XmlReaderTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(XmlReaderTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(XmlReaderTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(XmlReaderTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(XmlReaderTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_aes_crypt.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for aes_crypt.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(aes_cryptMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(aes_cryptMigrationTest, CompilationStub)
-TEST(aes_cryptMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(aes_cryptMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(aes_cryptMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(aes_cryptMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_aes_crypt_test.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for aes_crypt_test.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(aes_crypt_testMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(aes_crypt_testMigrationTest, CompilationStub)
-TEST(aes_crypt_testMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(aes_crypt_testMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(aes_crypt_testMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(aes_crypt_testMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_aes_dtc.cpp

@@ -13,7 +13,8 @@
 /**
  * @test Test dass der Header kompiliert und Namespace existiert
  */
-TEST(AesDtcTest, HeaderCompilesAndNamespaceExists) {
+TEST(AesDtcTest, HeaderCompilesAndNamespaceExists)
+{
     // Verify that the namespace and forward declarations exist
     // This test ensures the stub header compiles correctly
     using namespace AreaEffectSimulation;
@@ -31,7 +32,8 @@ TEST(AesDtcTest, HeaderCompilesAndNamespaceExists) {
 /**
  * @test Test dass Namespace-Struktur korrekt ist
  */
-TEST(AesDtcTest, NamespaceStructure) {
+TEST(AesDtcTest, NamespaceStructure)
+{
     // Verify nested namespace structure
     using DtcType = AreaEffectSimulation::Interface::Dtc;
     using FtcType = AreaEffectSimulation::Interface::Ftc;
@@ -46,10 +48,11 @@ TEST(AesDtcTest, NamespaceStructure) {
 /**
  * @test Test dass Header mehrfach inkludierbar ist (include guard)
  */
-TEST(AesDtcTest, MultipleIncludeGuard) {
+TEST(AesDtcTest, MultipleIncludeGuard)
-    // Including the header multiple times should not cause errors
+{
-    // This is implicitly tested by including it again here
+// Including the header multiple times should not cause errors
-    #include "AreaEffectSimulation/aes_dtc.h"
+// 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);

qt6-after/qt6-migrated-benchmark/tests/test_aes_enums.cpp

@@ -13,7 +13,8 @@
 /**
  * @test Test dass der Header kompiliert und Enums existieren
  */
-TEST(AesEnumsTest, HeaderCompilesAndEnumsExist) {
+TEST(AesEnumsTest, HeaderCompilesAndEnumsExist)
+{
     // Verify that enum classes are accessible
     using namespace AreaEffectSimulation;
 
@@ -33,7 +34,8 @@ TEST(AesEnumsTest, HeaderCompilesAndEnumsExist) {
 /**
  * @test Test dass UnitSymbolPosition struct korrekt ist
  */
-TEST(AesEnumsTest, UnitSymbolPositionStruct) {
+TEST(AesEnumsTest, UnitSymbolPositionStruct)
+{
     using namespace AreaEffectSimulation;
 
     // Test default initialization
@@ -55,10 +57,11 @@ TEST(AesEnumsTest, UnitSymbolPositionStruct) {
 /**
  * @test Test dass Header mehrfach inkludierbar ist (include guard)
  */
-TEST(AesEnumsTest, MultipleIncludeGuard) {
+TEST(AesEnumsTest, MultipleIncludeGuard)
-    // Including the header multiple times should not cause errors
+{
-    // This is implicitly tested by including it again here
+// Including the header multiple times should not cause errors
-    #include "AreaEffectSimulation/aes_enums.hpp"
+// 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);

qt6-after/qt6-migrated-benchmark/tests/test_app_chooser.cpp

@@ -3,8 +3,10 @@
 // Stub test for app_chooser.cpp migration validation
 // Actual implementation tests should be added based on app_chooser.cpp functionality
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 
 // Forward declarations to verify compilation
 class AppChooser;
@@ -12,21 +14,23 @@ class AppChooser;
 } // namespace Common
 } // namespace Lts
 
-TEST(AppChooserMigrationTest, CompilationStub) {
+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) {
+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) {
+TEST(AppChooserMigrationTest, BasicFunctionality)
+{
     // Basic functionality test placeholder
     // TODO: Implement actual functionality tests
     EXPECT_TRUE(true);
 }
-

qt6-after/qt6-migrated-benchmark/tests/test_app_chooser_model.cpp

@@ -3,8 +3,10 @@
 // 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 Lts
-namespace Common {
+{
+namespace Common
+{
 
 // Forward declarations to verify compilation
 class AppChooserModel;
@@ -12,21 +14,23 @@ class AppChooserModel;
 } // namespace Common
 } // namespace Lts
 
-TEST(AppChooserModelMigrationTest, CompilationStub) {
+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) {
+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) {
+TEST(AppChooserModelMigrationTest, BasicFunctionality)
+{
     // Basic functionality test placeholder
     // TODO: Implement actual functionality tests
     EXPECT_TRUE(true);
 }
-

qt6-after/qt6-migrated-benchmark/tests/test_asm_dtc.cpp

@@ -6,32 +6,35 @@
 #include <gtest/gtest.h>
 
 // Test that the header compiles and provides expected forward declarations
-TEST(AsmDtcTest, HeaderCompilesSuccessfully) {
+TEST(AsmDtcTest, HeaderCompilesSuccessfully)
-  // This test verifies that asm_dtc.h compiles without errors
+{
-  // The header provides forward declarations for DDS-generated Dtc/Ftc classes
+    // This test verifies that asm_dtc.h compiles without errors
-  EXPECT_TRUE(true);
+    // The header provides forward declarations for DDS-generated Dtc/Ftc classes
+    EXPECT_TRUE(true);
 }
 
-TEST(AsmDtcTest, NamespaceStructureExists) {
+TEST(AsmDtcTest, NamespaceStructureExists)
-  // Verify that the AssetManagement namespace exists
+{
-  using namespace AssetManagement;
+    // Verify that the AssetManagement namespace exists
+    using namespace AssetManagement;
 
-  // Verify that the Interface namespace exists within AssetManagement
+    // Verify that the Interface namespace exists within AssetManagement
-  using namespace AssetManagement::Interface;
+    using namespace AssetManagement::Interface;
 
-  // Forward declaration should be available (pointer type should compile)
+    // Forward declaration should be available (pointer type should compile)
-  Dtc* dtc_ptr = nullptr;
+    Dtc* dtc_ptr = nullptr;
-  Ftc* ftc_ptr = nullptr;
+    Ftc* ftc_ptr = nullptr;
 
-  EXPECT_EQ(dtc_ptr, nullptr);
+    EXPECT_EQ(dtc_ptr, nullptr);
-  EXPECT_EQ(ftc_ptr, nullptr);
+    EXPECT_EQ(ftc_ptr, nullptr);
 }
 
-TEST(AsmDtcTest, ForwardDeclarationsAreUsable) {
+TEST(AsmDtcTest, ForwardDeclarationsAreUsable)
-  // Test that forward-declared types can be used in function signatures
+{
-  auto use_dtc = [](AssetManagement::Interface::Dtc* ptr) { return ptr != nullptr; };
+    // Test that forward-declared types can be used in function signatures
-  auto use_ftc = [](AssetManagement::Interface::Ftc* ptr) { return ptr != nullptr; };
+    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_dtc(nullptr));
-  EXPECT_FALSE(use_ftc(nullptr));
+    EXPECT_FALSE(use_ftc(nullptr));
 }

qt6-after/qt6-migrated-benchmark/tests/test_asm_enums.cpp

@@ -3,23 +3,27 @@
  * @brief Tests for AssetManagement enum definitions
  */
 
-#include <gtest/gtest.h>
 #include "AssetManagement/asm_enums.hpp"
 
-TEST(AsmEnumsTest, SymbolAppearanceEnumValues) {
+#include <gtest/gtest.h>
-  EXPECT_EQ(AssetManagement::SymbolAppearance::Solid, 0);
+
-  EXPECT_EQ(AssetManagement::SymbolAppearance::Dashed, 1);
+TEST(AsmEnumsTest, SymbolAppearanceEnumValues)
-  EXPECT_EQ(AssetManagement::SymbolAppearance::Dotted, 2);
+{
+    EXPECT_EQ(AssetManagement::SymbolAppearance::Solid, 0);
+    EXPECT_EQ(AssetManagement::SymbolAppearance::Dashed, 1);
+    EXPECT_EQ(AssetManagement::SymbolAppearance::Dotted, 2);
 }
 
-TEST(AsmEnumsTest, SymbolVisibilityEnumValues) {
+TEST(AsmEnumsTest, SymbolVisibilityEnumValues)
-  EXPECT_EQ(AssetManagement::SymbolVisibility::Visible, 0);
+{
-  EXPECT_EQ(AssetManagement::SymbolVisibility::Hidden, 1);
+    EXPECT_EQ(AssetManagement::SymbolVisibility::Visible, 0);
+    EXPECT_EQ(AssetManagement::SymbolVisibility::Hidden, 1);
 }
 
-TEST(AsmEnumsTest, UnitSymbolPositionDefaultValues) {
+TEST(AsmEnumsTest, UnitSymbolPositionDefaultValues)
-  AssetManagement::UnitSymbolPosition pos;
+{
-  EXPECT_DOUBLE_EQ(pos.x, 0.0);
+    AssetManagement::UnitSymbolPosition pos;
-  EXPECT_DOUBLE_EQ(pos.y, 0.0);
+    EXPECT_DOUBLE_EQ(pos.x, 0.0);
-  EXPECT_DOUBLE_EQ(pos.z, 0.0);
+    EXPECT_DOUBLE_EQ(pos.y, 0.0);
+    EXPECT_DOUBLE_EQ(pos.z, 0.0);
 }

qt6-after/qt6-migrated-benchmark/tests/test_avm_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "AudioVideoManagement/avm_dtc.h"
 
-TEST(avm_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(avm_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_avm_enums.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "AudioVideoManagement/avm_enums.hpp"
 
-TEST(avm_enums_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(avm_enums_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_bld_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "Buildings/bld_dtc.h"
 
-TEST(bld_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(bld_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_bld_enums.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "Buildings/bld_enums.hpp"
 
-TEST(bld_enums_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(bld_enums_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_build_rti_guards.cpp

@@ -11,7 +11,8 @@
 #include <gtest/gtest.h>
 
 // Test 1: Verify BUILD_RTI macro is defined correctly
-TEST(BuildRTIGuards, MacroDefined) {
+TEST(BuildRTIGuards, MacroDefined)
+{
 #ifdef BUILD_RTI
     // When BUILD_RTI is enabled, it should be 1
     EXPECT_EQ(BUILD_RTI, 1);
@@ -23,7 +24,8 @@ TEST(BuildRTIGuards, MacroDefined) {
 }
 
 // Test 2: Verify DDS connector compiles without RTI
-TEST(BuildRTIGuards, DDSConnectorFallback) {
+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
@@ -31,11 +33,12 @@ TEST(BuildRTIGuards, DDSConnectorFallback) {
 #ifdef BUILD_RTI
     rti_available = true;
 #endif
-    EXPECT_FALSE(rti_available);  // In fallback mode, RTI is not available
+    EXPECT_FALSE(rti_available); // In fallback mode, RTI is not available
 }
 
 // Test 3: Verify conditional compilation doesn't break build
-TEST(BuildRTIGuards, ConditionalCompilationSafe) {
+TEST(BuildRTIGuards, ConditionalCompilationSafe)
+{
     // Verify that #if BUILD_RTI guards don't cause syntax errors
     int value = 0;
 #if BUILD_RTI

qt6-after/qt6-migrated-benchmark/tests/test_ces_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "CentralEffectSimulation/ces_dtc.h"
 
-TEST(ces_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(ces_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_client_message.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(client_messageTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(client_messageTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(client_messageTest, CompilationStub)
-TEST(client_messageTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(client_messageTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(client_messageTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_cmo_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "ComponentMonitor/cmo_dtc.h"
 
-TEST(cmo_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(cmo_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_cod_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "CodificationManagement/cod_dtc.h"
 
-TEST(cod_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(cod_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_codegen_export.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/codegen_export.h"
 
-TEST(codegen_exportTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(codegen_exportTest, MacrosDefined) { EXPECT_TRUE(true); }
+
-TEST(codegen_exportTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(codegen_exportTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(codegen_exportTest, MacrosDefined)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(codegen_exportTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_core_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "Core/core_dtc.h"
 
-TEST(core_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(core_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_core_enums.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "Core/core_enums.hpp"
 
-TEST(core_enums_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(core_enums_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_eem_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "ExerciseEventManagement/eem_dtc.h"
 
-TEST(eem_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(eem_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_eem_enums.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "Services/ExerciseEventManagement/eem_enums.hpp"
 
-TEST(eem_enums_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(eem_enums_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_elevation_unit_test.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for elevation_unit_test.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(elevation_unit_testMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(elevation_unit_testMigrationTest, CompilationStub)
-TEST(elevation_unit_testMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(elevation_unit_testMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(elevation_unit_testMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(elevation_unit_testMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_esc_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "EffectShowClient/esc_dtc.h"
 
-TEST(esc_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(esc_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_esm_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "EffectShowManagement/esm_dtc.h"
 
-TEST(esm_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(esm_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_evl_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "Evaluations/evl_dtc.h"
 
-TEST(evl_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(evl_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_exm_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "ExerciseManagement/exm_dtc.h"
 
-TEST(exm_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(exm_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_exm_enums.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "ExerciseManagement/exm_enums.hpp"
 
-TEST(exm_enums_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(exm_enums_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_export_headers.cpp

@@ -7,81 +7,89 @@
  * so we test header existence and structure rather than macro expansion.
  */
 
-#include <gtest/gtest.h>
 #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) {
+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::string readFile(const std::string& path)
+{
     std::ifstream file(path);
-    if (!file.is_open()) {
+    if (!file.is_open())
+    {
         return "";
     }
-    return std::string((std::istreambuf_iterator<char>(file)),
+    return std::string((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-                      std::istreambuf_iterator<char>());
 }
 
 // Test 1: nglwidgets_export.h exists
-TEST(ExportHeaders, NglWidgetsExportExists) {
+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) {
+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) {
+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) {
+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) {
+TEST(ExportHeaders, HaveIncludeGuards)
+{
     std::vector<std::string> headers = {
-        "build/Z/src/nglwidgets/nglwidgets_export.h",
+        "build/Z/src/nglwidgets/nglwidgets_export.h", "build/Z/src/QtSingleApplication/qtsingleapplication_export.h",
-        "build/Z/src/QtSingleApplication/qtsingleapplication_export.h",
+        "build/Lts/Common/LtsSession/ltssessiondata_export.h", "build/Lts/Proxies/ProjectDataManagement/pdm_export.h"};
-        "build/Lts/Common/LtsSession/ltssessiondata_export.h",
-        "build/Lts/Proxies/ProjectDataManagement/pdm_export.h"
-    };
 
-    for (const auto& header : headers) {
+    for (const auto& header : headers)
+    {
         std::string content = readFile(header);
-        if (!content.empty()) {
+        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) 
+            EXPECT_TRUE(hasIfndef && hasDefine && hasEndif) << "Header " << header << " missing proper include guards";
-                << "Header " << header << " missing proper include guards";
         }
     }
 }
 
 // Test 6: Export macros follow naming convention
-TEST(ExportHeaders, MacroNamingConvention) {
+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 adlerPath =
+        "qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Plugins/AdlerJson/adler_export.h";
     std::string content = readFile(adlerPath);
 
-    if (!content.empty()) {
+    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";
@@ -89,17 +97,23 @@ TEST(ExportHeaders, MacroNamingConvention) {
 }
 
 // Test 7: Export headers define both EXPORT and NO_EXPORT macros
-TEST(ExportHeaders, ExportAndNoExportMacros) {
+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/Services/PresentationManagement/"
-        {"qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Common/LtsSession/ltssessiondata_export.h", "LTSESSIONDATA"},
+         "svcprecommon_export.h",
-        {"qt-migration-legatus/qt6-after/qt6-migrated-legatus/build/Lts/Proxies/ProjectDataManagement/pdm_export.h", "PDM"}
+         "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) {
+    for (const auto& [header, prefix] : expectedMacros)
+    {
         std::string content = readFile(header);
-        if (!content.empty()) {
+        if (!content.empty())
+        {
             bool hasExport = content.find(prefix + "_EXPORT") != std::string::npos;
             bool hasNoExport = content.find(prefix + "_NO_EXPORT") != std::string::npos;
 

qt6-after/qt6-migrated-benchmark/tests/test_filter_background_widget.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(filter_background_widgetTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(filter_background_widgetTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(filter_background_widgetTest, CompilationStub)
-TEST(filter_background_widgetTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(filter_background_widgetTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(filter_background_widgetTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_filter_track_widget.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(filter_track_widgetTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(filter_track_widgetTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(filter_track_widgetTest, CompilationStub)
-TEST(filter_track_widgetTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(filter_track_widgetTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(filter_track_widgetTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_flm_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "FileManagement/flm_dtc.h"
 
-TEST(flm_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(flm_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_flm_enums.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "FileManagement/flm_enums.hpp"
 
-TEST(flm_enums_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(flm_enums_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_generic_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "DDS/DTC/generic_dtc.h"
 
-TEST(generic_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(generic_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_gim_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "GuezIedManagement/gim_dtc.h"
 
-TEST(gim_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(gim_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_gna_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "GuezNasat/gna_dtc.h"
 
-TEST(gna_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(gna_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_indicator.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(indicatorTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(indicatorTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(indicatorTest, CompilationStub)
-TEST(indicatorTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(indicatorTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(indicatorTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

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

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "include/InfrastructureManagement/ism_dtc.h"
 
-TEST(ism_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(ism_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_ism_enums.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "InfrastructureManagement/ism_enums.hpp"
 
-TEST(ism_enums_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(ism_enums_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_json_keys.h.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(json_keys.hTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(json_keys.hTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(json_keys.hTest, CompilationStub)
-TEST(json_keys.hTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(json_keys.hTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(json_keys.hTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_logger.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for logger.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(loggerMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(loggerMigrationTest, CompilationStub)
-TEST(loggerMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(loggerMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(loggerMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(loggerMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_logout_info_dialog.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for logout_info_dialog.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(logout_info_dialogMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(logout_info_dialogMigrationTest, CompilationStub)
-TEST(logout_info_dialogMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(logout_info_dialogMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(logout_info_dialogMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(logout_info_dialogMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lonlat2mgrs.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lonlat2mgrs.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lonlat2mgrsMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lonlat2mgrsMigrationTest, CompilationStub)
-TEST(lonlat2mgrsMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lonlat2mgrsMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lonlat2mgrsMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lonlat2mgrsMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_app_descriptor.cpp

@@ -1,6 +1,7 @@
 #include "lts_app_descriptor.h"
-#include <QJsonObject>
+
 #include <QJsonArray>
+#include <QJsonObject>
 #include <QString>
 #include <QStringList>
 #include <QtTest/QtTest>
@@ -12,7 +13,7 @@ class TestLtsAppDescriptor : public QObject
 {
     Q_OBJECT
 
-private slots:
+  private slots:
     void testPluginInfoCreation();
     void testPluginInfoFlagOperations();
     void testAppDescriptionDefaultConstruction();

qt6-after/qt6-migrated-benchmark/tests/test_lts_app_descriptor_editor.cpp

@@ -1,12 +1,13 @@
 #include "lts_app_descriptor_editor.h"
-#include <QtTest/QtTest>
+
 #include <QApplication>
+#include <QtTest/QtTest>
 
 class TestLtsAppDescriptorEditor : public QObject
 {
     Q_OBJECT
 
-private slots:
+  private slots:
     void testEditorConstruction();
     void testEditorDestruction();
     void testEditorInitialState();

qt6-after/qt6-migrated-benchmark/tests/test_lts_app_manager.cpp

@@ -3,8 +3,10 @@
 // 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 Lts
-namespace Common {
+{
+namespace Common
+{
 
 // Forward declarations to verify compilation
 class LtsAppManager;
@@ -12,21 +14,23 @@ class LtsAppManager;
 } // namespace Common
 } // namespace Lts
 
-TEST(LtsAppManagerMigrationTest, CompilationStub) {
+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) {
+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) {
+TEST(LtsAppManagerMigrationTest, BasicFunctionality)
+{
     // Basic functionality test placeholder
     // TODO: Implement actual functionality tests
     EXPECT_TRUE(true);
 }
-

qt6-after/qt6-migrated-benchmark/tests/test_lts_comport_querry.h.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_comport_querry.hTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_comport_querry.hTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_comport_querry.hTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_coord_trans.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_coord_trans.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_coord_transMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_coord_transMigrationTest, CompilationStub)
-TEST(lts_coord_transMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_coord_transMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_transMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_transMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_coord_trans_unit_test.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_coord_trans_unit_test.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_coord_trans_unit_testMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_coord_trans_unit_testMigrationTest, CompilationStub)
-TEST(lts_coord_trans_unit_testMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_coord_trans_unit_testMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_trans_unit_testMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_trans_unit_testMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_coord_vector.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_coord_vector.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_coord_vectorMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_coord_vectorMigrationTest, CompilationStub)
-TEST(lts_coord_vectorMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_coord_vectorMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_vectorMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_vectorMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_coord_widget.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_coord_widget.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_coord_widgetMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_coord_widgetMigrationTest, CompilationStub)
-TEST(lts_coord_widgetMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_coord_widgetMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_widgetMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_widgetMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_coord_widget_test.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_coord_widget_test.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_coord_widget_testMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_coord_widget_testMigrationTest, CompilationStub)
-TEST(lts_coord_widget_testMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_coord_widget_testMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_widget_testMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coord_widget_testMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_coordinate_unit_test.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_coordinate_unit_test.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_coordinate_unit_testMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_coordinate_unit_testMigrationTest, CompilationStub)
-TEST(lts_coordinate_unit_testMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_coordinate_unit_testMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coordinate_unit_testMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_coordinate_unit_testMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_dummy_widget.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_dummy_widget.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_dummy_widgetMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_dummy_widgetMigrationTest, CompilationStub)
-TEST(lts_dummy_widgetMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_dummy_widgetMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_dummy_widgetMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_dummy_widgetMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_elevation_manager.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_elevation_manager.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_elevation_managerMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_elevation_managerMigrationTest, CompilationStub)
-TEST(lts_elevation_managerMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_elevation_managerMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_elevation_managerMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_elevation_managerMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_licence.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_licence.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_licenceMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_licenceMigrationTest, CompilationStub)
-TEST(lts_licenceMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_licenceMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_licenceMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_licenceMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_login.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_login.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_loginMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_loginMigrationTest, CompilationStub)
-TEST(lts_loginMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_loginMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_loginMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_loginMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_magic_corner.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_magic_corner.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_magic_cornerMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_magic_cornerMigrationTest, CompilationStub)
-TEST(lts_magic_cornerMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_magic_cornerMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_magic_cornerMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_magic_cornerMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_multi_monitor.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_multi_monitor.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_multi_monitorMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_multi_monitorMigrationTest, CompilationStub)
-TEST(lts_multi_monitorMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_multi_monitorMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitorMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitorMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_multi_monitor_export.h.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for lts_multi_monitor_export.h.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(lts_multi_monitor_export.hMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(lts_multi_monitor_export.hMigrationTest, CompilationStub)
-TEST(lts_multi_monitor_export.hMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(lts_multi_monitor_export.hMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_export.hMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_export.hMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_multi_monitor_selector_base.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_multi_monitor_selector_baseTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_selector_baseTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_selector_baseTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_multi_monitor_selector_normal.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_multi_monitor_selector_normalTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_selector_normalTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_selector_normalTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_multi_monitor_selector_wide.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_multi_monitor_selector_wideTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_selector_wideTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_multi_monitor_selector_wideTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_notification.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_notificationTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_notificationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_notificationTest, CompilationStub)
-TEST(lts_notificationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_notificationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_notificationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_notification_ctl.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_notification_ctlTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_notification_ctlTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_notification_ctlTest, CompilationStub)
-TEST(lts_notification_ctlTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_notification_ctlTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_notification_ctlTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_notification_export.h.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_notification_export.hTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_notification_export.hTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_notification_export.hTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_plugin_loader.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_plugin_loaderTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_plugin_loaderTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_plugin_loaderTest, CompilationStub)
-TEST(lts_plugin_loaderTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_loaderTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_loaderTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_plugin_manager_dialog.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_plugin_manager_dialogTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_manager_dialogTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_manager_dialogTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_plugin_manager_export.h.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_plugin_manager_export.hTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_manager_export.hTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_manager_export.hTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_plugin_manager_widget.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_plugin_manager_widgetTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_manager_widgetTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_plugin_manager_widgetTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_projection_workstation.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_projection_workstationTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_projection_workstationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_projection_workstationTest, CompilationStub)
-TEST(lts_projection_workstationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_projection_workstationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_projection_workstationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_projection_workstation_export.h.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_projection_workstation_export.hTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_projection_workstation_export.hTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_projection_workstation_export.hTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_screen_base.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_screen_baseTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_screen_baseTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_screen_baseTest, CompilationStub)
-TEST(lts_screen_baseTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_baseTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_baseTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_screen_container.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_screen_containerTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_screen_containerTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_screen_containerTest, CompilationStub)
-TEST(lts_screen_containerTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_containerTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_containerTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_screen_normal.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_screen_normalTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_screen_normalTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_screen_normalTest, CompilationStub)
-TEST(lts_screen_normalTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_normalTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_normalTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_screen_wide.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_screen_wideTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_screen_wideTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_screen_wideTest, CompilationStub)
-TEST(lts_screen_wideTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_wideTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_screen_wideTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_serial_port_querry.cpp

@@ -1,4 +1,16 @@
 #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, CompilationStub)
-TEST(lts_serial_port_querryTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_serial_port_querryTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_serial_port_querryTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_session.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_sessionTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_sessionTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_sessionTest, CompilationStub)
-TEST(lts_sessionTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_sessionTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_sessionTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_session_data.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_session_dataTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_session_dataTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_session_dataTest, CompilationStub)
-TEST(lts_session_dataTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_session_dataTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_session_dataTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_lts_session_data_dds.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(lts_session_data_ddsTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(lts_session_data_ddsTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(lts_session_data_ddsTest, CompilationStub)
-TEST(lts_session_data_ddsTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_session_data_ddsTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(lts_session_data_ddsTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_ltswidgets_qt6.cpp

@@ -9,32 +9,37 @@
  * 4. QStyleOption::initFrom() usage
  */
 
-#include <gtest/gtest.h>
-#include <QRandomGenerator>
-#include <QComboBox>
-#include <QWheelEvent>
-#include <QStyleOption>
-#include <QPushButton>
 #include <QApplication>
+#include <QComboBox>
+#include <QPushButton>
+#include <QRandomGenerator>
+#include <QStyleOption>
+#include <QWheelEvent>
+#include <gtest/gtest.h>
 
 // Ensure QApplication is initialized for widget tests
 static bool appInitialized = false;
-static void ensureAppInitialized() {
+
-    if (!appInitialized) {
+static void ensureAppInitialized()
+{
+    if (!appInitialized)
+    {
         static int argc = 1;
-        static char* argv[] = { (char*)"test_ltswidgets_qt6", nullptr };
+        static char* argv[] = {(char*)"test_ltswidgets_qt6", nullptr};
         static QApplication app(argc, argv);
         appInitialized = true;
     }
 }
 
 // Test 1: QRandomGenerator bounded generation (used in lts_tab_widget.cpp)
-TEST(LtsWidgetsQt6, QRandomGeneratorBounded) {
+TEST(LtsWidgetsQt6, QRandomGeneratorBounded)
+{
     auto* generator = QRandomGenerator::global();
     ASSERT_NE(generator, nullptr);
 
     // Test multiple bounded calls to ensure stability
-    for (int i = 0; i < 100; ++i) {
+    for (int i = 0; i < 100; ++i)
+    {
         int value = generator->bounded(10);
         EXPECT_GE(value, 0);
         EXPECT_LT(value, 10);
@@ -42,18 +47,22 @@ TEST(LtsWidgetsQt6, QRandomGeneratorBounded) {
 }
 
 // Test 2: QRandomGenerator produces different values
-TEST(LtsWidgetsQt6, QRandomGeneratorVariation) {
+TEST(LtsWidgetsQt6, QRandomGeneratorVariation)
+{
     auto* generator = QRandomGenerator::global();
 
     QVector<int> values;
-    for (int i = 0; i < 50; ++i) {
+    for (int i = 0; i < 50; ++i)
+    {
         values.append(generator->bounded(1000));
     }
 
     // Check that we get some variation (not all same value)
     bool hasDifferent = false;
-    for (int i = 1; i < values.size(); ++i) {
+    for (int i = 1; i < values.size(); ++i)
-        if (values[i] != values[0]) {
+    {
+        if (values[i] != values[0])
+        {
             hasDifferent = true;
             break;
         }
@@ -62,19 +71,22 @@ TEST(LtsWidgetsQt6, QRandomGeneratorVariation) {
 }
 
 // Test 3: QRandomGenerator seeded reproducibility
-TEST(LtsWidgetsQt6, QRandomGeneratorSeeded) {
+TEST(LtsWidgetsQt6, QRandomGeneratorSeeded)
+{
     QRandomGenerator gen1(12345);
     QRandomGenerator gen2(12345);
 
     // Same seed should produce same sequence
-    for (int i = 0; i < 10; ++i) {
+    for (int i = 0; i < 10; ++i)
+    {
         EXPECT_EQ(gen1.bounded(1000), gen2.bounded(1000));
     }
 }
 
 // Test 4: QComboBox currentTextChanged signal (Qt6 compatible)
 // This tests the signal used in lts_text_editor.cpp
-TEST(LtsWidgetsQt6, QComboBoxCurrentTextChangedSignal) {
+TEST(LtsWidgetsQt6, QComboBoxCurrentTextChangedSignal)
+{
     ensureAppInitialized();
 
     QComboBox comboBox;
@@ -85,11 +97,10 @@ TEST(LtsWidgetsQt6, QComboBoxCurrentTextChangedSignal) {
     bool signalReceived = false;
     QString receivedText;
 
-    QObject::connect(&comboBox, &QComboBox::currentTextChanged,
+    QObject::connect(&comboBox, &QComboBox::currentTextChanged, [&signalReceived, &receivedText](const QString& text) {
-        [&signalReceived, &receivedText](const QString& text) {
+        signalReceived = true;
-            signalReceived = true;
+        receivedText = text;
-            receivedText = text;
+    });
-        });
 
     comboBox.setCurrentIndex(1);
 
@@ -99,7 +110,8 @@ TEST(LtsWidgetsQt6, QComboBoxCurrentTextChangedSignal) {
 
 // Test 5: QComboBox activated signal with int parameter (Qt6)
 // Note: activated signal is only emitted on user interaction, not on setCurrentIndex
-TEST(LtsWidgetsQt6, QComboBoxActivatedIntSignal) {
+TEST(LtsWidgetsQt6, QComboBoxActivatedIntSignal)
+{
     ensureAppInitialized();
 
     QComboBox comboBox;
@@ -112,10 +124,10 @@ TEST(LtsWidgetsQt6, QComboBoxActivatedIntSignal) {
 
     // Connect using Qt6 syntax - activated emits int index
     QObject::connect(&comboBox, QOverload<int>::of(&QComboBox::activated),
-        [&signalReceived, &receivedIndex](int index) {
+                     [&signalReceived, &receivedIndex](int index) {
-            signalReceived = true;
+                         signalReceived = true;
-            receivedIndex = index;
+                         receivedIndex = index;
-        });
+                     });
 
     // Simulate user interaction by emitting the signal manually
     // (setCurrentIndex does not trigger activated signal)
@@ -129,7 +141,8 @@ TEST(LtsWidgetsQt6, QComboBoxActivatedIntSignal) {
 
 // Test 6: QStyleOption::initFrom() (Qt6 replacement for init())
 // This tests the API used in lts_notification_box.cpp
-TEST(LtsWidgetsQt6, QStyleOptionInitFrom) {
+TEST(LtsWidgetsQt6, QStyleOptionInitFrom)
+{
     ensureAppInitialized();
 
     QPushButton button("Test");
@@ -146,7 +159,8 @@ TEST(LtsWidgetsQt6, QStyleOptionInitFrom) {
 }
 
 // Test 7: QStyleOption multiple widgets
-TEST(LtsWidgetsQt6, QStyleOptionInitFromMultipleWidgets) {
+TEST(LtsWidgetsQt6, QStyleOptionInitFromMultipleWidgets)
+{
     ensureAppInitialized();
 
     QPushButton button1("Btn1");
@@ -167,17 +181,17 @@ TEST(LtsWidgetsQt6, QStyleOptionInitFromMultipleWidgets) {
 
 // Test 8: QWheelEvent angleDelta() availability
 // This verifies the API used in lts_date_time_edit_p.cpp
-TEST(LtsWidgetsQt6, QWheelEventAngleDelta) {
+TEST(LtsWidgetsQt6, QWheelEventAngleDelta)
+{
     ensureAppInitialized();
 
     QPoint pos(100, 100);
     QPoint globalPos(200, 200);
     QPoint pixelDelta(0, 0);
-    QPoint angleDelta(0, 120);  // Standard wheel step
+    QPoint angleDelta(0, 120); // Standard wheel step
 
-    QWheelEvent wheelEvent(pos, globalPos, pixelDelta, angleDelta,
+    QWheelEvent wheelEvent(pos, globalPos, pixelDelta, angleDelta, Qt::NoButton, Qt::NoModifier, Qt::NoScrollPhase,
-                           Qt::NoButton, Qt::NoModifier,
+                           false);
-                           Qt::NoScrollPhase, false);
 
     // Verify angleDelta() is accessible and returns correct value
     QPoint delta = wheelEvent.angleDelta();
@@ -186,17 +200,17 @@ TEST(LtsWidgetsQt6, QWheelEventAngleDelta) {
 }
 
 // Test 9: QWheelEvent negative angleDelta
-TEST(LtsWidgetsQt6, QWheelEventNegativeAngleDelta) {
+TEST(LtsWidgetsQt6, QWheelEventNegativeAngleDelta)
+{
     ensureAppInitialized();
 
     QPoint pos(100, 100);
     QPoint globalPos(200, 200);
     QPoint pixelDelta(0, 0);
-    QPoint angleDelta(0, -120);  // Scroll down
+    QPoint angleDelta(0, -120); // Scroll down
 
-    QWheelEvent wheelEvent(pos, globalPos, pixelDelta, angleDelta,
+    QWheelEvent wheelEvent(pos, globalPos, pixelDelta, angleDelta, Qt::NoButton, Qt::NoModifier, Qt::NoScrollPhase,
-                           Qt::NoButton, Qt::NoModifier,
+                           false);
-                           Qt::NoScrollPhase, false);
 
     QPoint delta = wheelEvent.angleDelta();
     EXPECT_EQ(delta.y(), -120);
@@ -207,18 +221,19 @@ TEST(LtsWidgetsQt6, QWheelEventNegativeAngleDelta) {
 }
 
 // Test 10: QWheelEvent angleDelta direction detection
-TEST(LtsWidgetsQt6, QWheelEventDirectionDetection) {
+TEST(LtsWidgetsQt6, QWheelEventDirectionDetection)
+{
     ensureAppInitialized();
 
     // Simulate wheel up (positive delta)
     QPoint angleDeltaUp(0, 120);
-    QWheelEvent wheelUp(QPoint(0, 0), QPoint(0, 0), QPoint(0, 0), angleDeltaUp,
+    QWheelEvent wheelUp(QPoint(0, 0), QPoint(0, 0), QPoint(0, 0), angleDeltaUp, Qt::NoButton, Qt::NoModifier,
-                        Qt::NoButton, Qt::NoModifier, Qt::NoScrollPhase, false);
+                        Qt::NoScrollPhase, false);
     EXPECT_TRUE(wheelUp.angleDelta().y() > 0);
 
     // Simulate wheel down (negative delta)
     QPoint angleDeltaDown(0, -120);
-    QWheelEvent wheelDown(QPoint(0, 0), QPoint(0, 0), QPoint(0, 0), angleDeltaDown,
+    QWheelEvent wheelDown(QPoint(0, 0), QPoint(0, 0), QPoint(0, 0), angleDeltaDown, Qt::NoButton, Qt::NoModifier,
-                          Qt::NoButton, Qt::NoModifier, Qt::NoScrollPhase, false);
+                          Qt::NoScrollPhase, false);
     EXPECT_FALSE(wheelDown.angleDelta().y() > 0);
 }

qt6-after/qt6-migrated-benchmark/tests/test_main_grantlee.cpp

@@ -1,5 +1,17 @@
 #include <gtest/gtest.h>
+
 // main_grantlee.cpp is typically a main entry point, test compilation only
-TEST(main_grantleeTest, Compiles) { EXPECT_TRUE(true); }
+TEST(main_grantleeTest, Compiles)
-TEST(main_grantleeTest, Linkage) { EXPECT_TRUE(true); }
+{
-TEST(main_grantleeTest, EntryPoint) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(main_grantleeTest, Linkage)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(main_grantleeTest, EntryPoint)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_main_grantlee_gui.cpp

@@ -1,6 +1,18 @@
-#include <gtest/gtest.h>
 #include "Lts/Common/CodeGen/main_grantlee_gui.h"
 
-TEST(main_grantlee_guiTest, HeaderCompiles) { EXPECT_TRUE(true); }
+#include <gtest/gtest.h>
-TEST(main_grantlee_guiTest, CanInstantiate) { EXPECT_TRUE(true); }
+
-TEST(main_grantlee_guiTest, NamespaceExists) { EXPECT_TRUE(true); }
+TEST(main_grantlee_guiTest, HeaderCompiles)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(main_grantlee_guiTest, CanInstantiate)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(main_grantlee_guiTest, NamespaceExists)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_mainwindow.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(mainwindowTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(mainwindowTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(mainwindowTest, CompilationStub)
-TEST(mainwindowTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(mainwindowTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(mainwindowTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_mdm_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "include/MeteoDataManagement/mdm_dtc.h"
 
-TEST(mdm_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(mdm_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_message_factory.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(message_factoryTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(message_factoryTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(message_factoryTest, CompilationStub)
-TEST(message_factoryTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(message_factoryTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(message_factoryTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_messages.cpp

@@ -1,4 +1,16 @@
 #include <gtest/gtest.h>
-TEST(messagesTest, CompilationStub) { EXPECT_TRUE(true); }
+
-TEST(messagesTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+TEST(messagesTest, CompilationStub)
-TEST(messagesTest, BasicFunctionality) { EXPECT_TRUE(true); }
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(messagesTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(messagesTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_mgrs2lonlat.cpp

@@ -2,11 +2,24 @@
 
 // Stub test for mgrs2lonlat.cpp migration validation
 
-namespace Lts {
+namespace Lts
-namespace Common {
+{
+namespace Common
+{
 } // namespace Common
 } // namespace Lts
 
-TEST(mgrs2lonlatMigrationTest, CompilationStub) { EXPECT_TRUE(true); }
+TEST(mgrs2lonlatMigrationTest, CompilationStub)
-TEST(mgrs2lonlatMigrationTest, Qt6ApiCompatibility) { EXPECT_TRUE(true); }
+{
-TEST(mgrs2lonlatMigrationTest, BasicFunctionality) { EXPECT_TRUE(true); }
+    EXPECT_TRUE(true);
+}
+
+TEST(mgrs2lonlatMigrationTest, Qt6ApiCompatibility)
+{
+    EXPECT_TRUE(true);
+}
+
+TEST(mgrs2lonlatMigrationTest, BasicFunctionality)
+{
+    EXPECT_TRUE(true);
+}

qt6-after/qt6-migrated-benchmark/tests/test_migration_stubs.cpp

@@ -10,12 +10,14 @@
 #include <gtest/gtest.h>
 
 // Test that the test framework is working
-TEST(MigrationStubs, TestFrameworkWorks) {
+TEST(MigrationStubs, TestFrameworkWorks)
+{
     EXPECT_TRUE(true);
 }
 
 // Test that basic Qt6 types are available
-TEST(MigrationStubs, Qt6TypesAvailable) {
+TEST(MigrationStubs, Qt6TypesAvailable)
+{
     QString test = "Qt6 migration";
     EXPECT_FALSE(test.isEmpty());
 }
@@ -25,7 +27,9 @@ TEST(MigrationStubs, Qt6TypesAvailable) {
 
 // AlarmManagement
 #include "AlarmManagement/alm_dtc.h"
-TEST(MigrationStubs, AlarmManagementDtcCompiles) {
+
+TEST(MigrationStubs, AlarmManagementDtcCompiles)
+{
     // Forward declaration only - verify namespace exists
     using namespace AlarmManagement::Interface;
     EXPECT_TRUE(true);
@@ -33,147 +37,189 @@ TEST(MigrationStubs, AlarmManagementDtcCompiles) {
 
 // AreaEffectSimulation
 #include "AreaEffectSimulation/aes_dtc.h"
-TEST(MigrationStubs, AreaEffectSimulationDtcCompiles) {
+
+TEST(MigrationStubs, AreaEffectSimulationDtcCompiles)
+{
     using namespace AreaEffectSimulation::Interface;
     EXPECT_TRUE(true);
 }
 
 // AssetManagement
 #include "AssetManagement/asm_dtc.h"
-TEST(MigrationStubs, AssetManagementDtcCompiles) {
+
+TEST(MigrationStubs, AssetManagementDtcCompiles)
+{
     using namespace AssetManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // AudioVideoManagement
 #include "AudioVideoManagement/avm_dtc.h"
-TEST(MigrationStubs, AudioVideoManagementDtcCompiles) {
+
+TEST(MigrationStubs, AudioVideoManagementDtcCompiles)
+{
     using namespace AudioVideoManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // Buildings
 #include "Buildings/bld_dtc.h"
-TEST(MigrationStubs, BuildingsDtcCompiles) {
+
+TEST(MigrationStubs, BuildingsDtcCompiles)
+{
     using namespace Buildings::Interface;
     EXPECT_TRUE(true);
 }
 
 // CentralEffectSimulation
 #include "CentralEffectSimulation/ces_dtc.h"
-TEST(MigrationStubs, CentralEffectSimulationDtcCompiles) {
+
+TEST(MigrationStubs, CentralEffectSimulationDtcCompiles)
+{
     using namespace CentralEffectSimulation::Interface;
     EXPECT_TRUE(true);
 }
 
 // CodificationManagement
 #include "CodificationManagement/cod_dtc.h"
-TEST(MigrationStubs, CodificationManagementDtcCompiles) {
+
+TEST(MigrationStubs, CodificationManagementDtcCompiles)
+{
     using namespace CodificationManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // ComponentMonitor
 #include "ComponentMonitor/cmo_dtc.h"
-TEST(MigrationStubs, ComponentMonitorDtcCompiles) {
+
+TEST(MigrationStubs, ComponentMonitorDtcCompiles)
+{
     using namespace ComponentMonitor::Interface;
     EXPECT_TRUE(true);
 }
 
 // Core
 #include "Core/core_dtc.h"
-TEST(MigrationStubs, CoreDtcCompiles) {
+
+TEST(MigrationStubs, CoreDtcCompiles)
+{
     using namespace Core::Interface;
     EXPECT_TRUE(true);
 }
 
 // DDS Core
 #include "DDS/Core/core_dtc.h"
-TEST(MigrationStubs, DDSCoreDtcCompiles) {
+
+TEST(MigrationStubs, DDSCoreDtcCompiles)
+{
     using namespace DDS::Core::Interface;
     EXPECT_TRUE(true);
 }
 
 // DDS DTC
 #include "DDS/DTC/generic_dtc.h"
-TEST(MigrationStubs, DDSDtcCompiles) {
+
+TEST(MigrationStubs, DDSDtcCompiles)
+{
     using namespace DDS::DTC;
     EXPECT_TRUE(true);
 }
 
 // EffectShowClient
 #include "EffectShowClient/esc_dtc.h"
-TEST(MigrationStubs, EffectShowClientDtcCompiles) {
+
+TEST(MigrationStubs, EffectShowClientDtcCompiles)
+{
     using namespace EffectShowClient::Interface;
     EXPECT_TRUE(true);
 }
 
 // EffectShowManagement
 #include "EffectShowManagement/esm_dtc.h"
-TEST(MigrationStubs, EffectShowManagementDtcCompiles) {
+
+TEST(MigrationStubs, EffectShowManagementDtcCompiles)
+{
     using namespace EffectShowManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // Evaluations
 #include "Evaluations/evl_dtc.h"
-TEST(MigrationStubs, EvaluationsDtcCompiles) {
+
+TEST(MigrationStubs, EvaluationsDtcCompiles)
+{
     using namespace Evaluations::Interface;
     EXPECT_TRUE(true);
 }
 
 // ExerciseEventManagement
 #include "ExerciseEventManagement/eem_dtc.h"
-TEST(MigrationStubs, ExerciseEventManagementDtcCompiles) {
+
+TEST(MigrationStubs, ExerciseEventManagementDtcCompiles)
+{
     using namespace ExerciseEventManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // ExerciseManagement
 #include "ExerciseManagement/exm_dtc.h"
-TEST(MigrationStubs, ExerciseManagementDtcCompiles) {
+
+TEST(MigrationStubs, ExerciseManagementDtcCompiles)
+{
     using namespace ExerciseManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // FileManagement
 #include "FileManagement/flm_dtc.h"
-TEST(MigrationStubs, FileManagementDtcCompiles) {
+
+TEST(MigrationStubs, FileManagementDtcCompiles)
+{
     using namespace FileManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // GuezIedManagement
 #include "GuezIedManagement/gim_dtc.h"
-TEST(MigrationStubs, GuezIedManagementDtcCompiles) {
+
+TEST(MigrationStubs, GuezIedManagementDtcCompiles)
+{
     using namespace GuezIedManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // GuezNasat
 #include "GuezNasat/gna_dtc.h"
-TEST(MigrationStubs, GuezNasatDtcCompiles) {
+
+TEST(MigrationStubs, GuezNasatDtcCompiles)
+{
     using namespace GuezNasat::Interface;
     EXPECT_TRUE(true);
 }
 
 // InfrastructureManagement
 #include "InfrastructureManagement/ism_dtc.h"
-TEST(MigrationStubs, InfrastructureManagementDtcCompiles) {
+
+TEST(MigrationStubs, InfrastructureManagementDtcCompiles)
+{
     using namespace InfrastructureManagement::Interface;
     EXPECT_TRUE(true);
 }
 
 // Generic DTC
 #include "generic_dtc.h"
-TEST(MigrationStubs, GenericDtcCompiles) {
+
+TEST(MigrationStubs, GenericDtcCompiles)
+{
     using namespace Generic;
     EXPECT_TRUE(true);
 }
 
 // AES DTC (root level)
 #include "aes_dtc.h"
-TEST(MigrationStubs, AesDtcCompiles) {
+
+TEST(MigrationStubs, AesDtcCompiles)
+{
     using namespace AES;
     EXPECT_TRUE(true);
 }

qt6-after/qt6-migrated-benchmark/tests/test_mockcoordtrans.cpp

@@ -1,8 +1,10 @@
 #include "MockCoordTrans.h"
+
 #include <gtest/gtest.h>
 
 // MockCoordTrans compilation test
-TEST(MockCoordTransTest, CanInstantiate) {
+TEST(MockCoordTransTest, CanInstantiate)
+{
     // Verify MockCoordTrans compiles and can be instantiated
     // This is a stub test to satisfy policy requirements
     EXPECT_TRUE(true);

qt6-after/qt6-migrated-benchmark/tests/test_mrk_dtc.cpp

@@ -5,10 +5,12 @@
  * This test verifies that the migrated header compiles correctly with Qt6/C++23.
  */
 
-#include <gtest/gtest.h>
 #include "include/MarkerManagement/mrk_dtc.h"
 
-TEST(mrk_dtc_Compilation, HeaderCompiles) {
+#include <gtest/gtest.h>
+
+TEST(mrk_dtc_Compilation, HeaderCompiles)
+{
     // This test verifies that the header compiles without errors
     EXPECT_TRUE(true);
 }