Review fomattings

Author: Twon

libraries/core/tests/serialisation/binary_reader.tests.cpp

@@ -31,8 +31,8 @@ namespace morpheus::serialisation
 
 TEST_CASE("Binary reader handles error cases gracefully", "[morpheus.serialisation.binary_reader.error_handling]")
 {
-    auto constexpr bytes = testing::makeBytes(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
-    auto constexpr string = std::string_view{"String longer than 4-bytes"};
+    constexpr auto bytes = testing::makeBytes(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+    constexpr auto string = std::string_view{"String longer than 4-bytes"};
 
 #if (__cpp_lib_spanstream >= 202106L)
     SECTION("Serialise via spanstream to test failure condition when the the underling stream runs out of memory while writing but does not throw an exception")

libraries/core/tests/serialisation/binary_roundtrip.tests.cpp

@@ -48,10 +48,10 @@ TEST_CASE("Binary serialisation can roundtrip standard library types to binary a
     REQUIRE(roundtrip(std::pair<int, bool>{50, true}) == std::pair<int, bool>{50, true});
     REQUIRE(roundtrip(std::string("Hello")) == std::string("Hello"));
     REQUIRE(*roundtrip(std::make_unique<int>(123)) == 123);
-    //REQUIRE(roundtrip(std::vector<int>{1, 2, 3, 4, 5}) == std::vector<int>{1, 2, 3, 4, 5});
+    // REQUIRE(roundtrip(std::vector<int>{1, 2, 3, 4, 5}) == std::vector<int>{1, 2, 3, 4, 5});
 
     /*  REQUIRE(test::serialise(std::variant<int, bool, std::string>{true}) == R"({"type":"bool","value":true})");
-    */
+     */
 }
 
 } // namespace morpheus::serialisation

libraries/core/tests/serialisation/binary_writer.tests.cpp

@@ -28,8 +28,8 @@ namespace morpheus::serialisation
 
 TEST_CASE("Binary writer handles error cases gracefully", "[morpheus.serialisation.binary_writer.error_handling]")
 {
-    auto constexpr bytes = testing::makeBytes(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
-    auto constexpr string = std::string_view{"String longer than 4-bytes"};
+    constexpr auto bytes = testing::makeBytes(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+    constexpr auto string = std::string_view{"String longer than 4-bytes"};
 
 #if (__cpp_lib_spanstream >= 202106L)
     SECTION("Serialise via spanstream to test failure condition when the the underling stream runs out of memory while writing but does not throw an exception")
@@ -74,12 +74,12 @@ TEST_CASE("Binary writer can write std types to underlying text representation",
         REQUIRE(test::serialisationRoundtrip(std::chrono::years{100}) == std::chrono::years{100});
         REQUIRE(test::serialisationRoundtrip(std::chrono::months{12}) == std::chrono::months{12});*/
     }
-/*    REQUIRE(test::serialisationRoundtrip(std::monostate{}) == std::monostate{});
-    REQUIRE(test::serialisationRoundtrip(std::optional<int>{100}) == std::optional<int>{100});
-    REQUIRE(test::serialisationRoundtrip(std::optional<int>{}) == std::optional<int>{});
-    REQUIRE(test::serialisationRoundtrip(std::pair<int, bool>{50, true}) == std::pair<int, bool>{50, true});
-    REQUIRE(*test::serialisationRoundtrip(std::make_unique<int>(123)) == 123);
-    */
+    /*    REQUIRE(test::serialisationRoundtrip(std::monostate{}) == std::monostate{});
+        REQUIRE(test::serialisationRoundtrip(std::optional<int>{100}) == std::optional<int>{100});
+        REQUIRE(test::serialisationRoundtrip(std::optional<int>{}) == std::optional<int>{});
+        REQUIRE(test::serialisationRoundtrip(std::pair<int, bool>{50, true}) == std::pair<int, bool>{50, true});
+        REQUIRE(*test::serialisationRoundtrip(std::make_unique<int>(123)) == 123);
+        */
     /*  REQUIRE(test::serialise(std::variant<int, bool, std::string>{true}) == R"({"type":"bool","value":true})");
         REQUIRE(test::serialise(std::vector<int>{1, 2, 3, 4, 5}) == R"([1,2,3,4,5])");
     */

libraries/gfx/d3d12/src/morpheus/gfx/d3d12/adapter.cpp

@@ -27,50 +27,43 @@ auto createDXGIFactory()
     return dxgiFactory;
 }
 
-auto getAdapterDescription(const DXGIAdapter& adapter)
+auto getAdapterDescription(DXGIAdapter const& adapter)
 {
     DXGI_ADAPTER_DESC1 desc{};
     MORPHEUS_D3D12_VERIFY(adapter->GetDesc1(&desc));
     return desc;
 }
 
-auto getOutputModes(const DXGIOutput& output)
+auto getOutputModes(DXGIOutput const& output)
 {
-	UINT numModes = 0;
+    UINT numModes = 0;
     MORPHEUS_D3D12_VERIFY(output->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, 0, &numModes, nullptr));
 
     std::vector<DXGI_MODE_DESC> displayModes(numModes);
     MORPHEUS_D3D12_VERIFY(output->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, 0, &numModes, displayModes.data()));
     return displayModes;
 }
 
-auto getOutputModes(const DXGIAdapter& adapter)
+auto getOutputModes(DXGIAdapter const& adapter)
 {
     DXGIOutput output;
     std::vector<DXGI_MODE_DESC> displayModes;
 
     for (UINT outputCount = 0; DXGI_ERROR_NOT_FOUND != adapter->EnumOutputs(outputCount, &output); ++outputCount)
     {
         auto outputDisplayModes = getOutputModes(output);
-        displayModes.insert(
-            displayModes.end(),
-            std::make_move_iterator(outputDisplayModes.begin()),
-            std::make_move_iterator(outputDisplayModes.end())
-        );
+        displayModes.insert(displayModes.end(), std::make_move_iterator(outputDisplayModes.begin()), std::make_move_iterator(outputDisplayModes.end()));
     }
 
     return displayModes;
 }
 
-}
+} // namespace
 
-Adapter::Adapter(
-    DXGIAdapter dxgiAdapter
-)
-:   mDxgiAdapter(std::move(dxgiAdapter))
-,   mDescription(getAdapterDescription(mDxgiAdapter))
-{
-}
+Adapter::Adapter(DXGIAdapter dxgiAdapter)
+    : mDxgiAdapter(std::move(dxgiAdapter))
+    , mDescription(getAdapterDescription(mDxgiAdapter))
+{}
 
 [[nodiscard]] Vendor Adapter::vendor() const noexcept
 {
@@ -86,9 +79,9 @@ concurrency::Generator<Adapter> enumerateAdapters()
     for (UINT adapterId = 0; DXGI_ERROR_NOT_FOUND != dxgiFactory->EnumAdapters1(adapterId, &pDXGIAdapter); ++adapterId)
     {
         // Ignore software adapters
-//        if (graphics_adapter.dxgi_description.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) {
-//            continue;
-//        }
+        // if (graphics_adapter.dxgi_description.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) {
+        //     continue;
+        // }
 
         co_yield Adapter(pDXGIAdapter);
     }

libraries/gfx/d3d12/tests/adapter.tests.cpp

@@ -1,25 +1,21 @@
-#include <morpheus/gfx/d3d12/adapter.hpp>
 #include <catch2/catch_all.hpp>
+#include <morpheus/gfx/d3d12/adapter.hpp>
 
 namespace morpheus::gfx::d3d12::test
 {
-//using namespace morpheus::gfx;
+// using namespace morpheus::gfx;
 
-TEST_CASE("Create an adapter mode list", "[morpheus.gfx.d3d12.adapter_list]")
-{
-}
+TEST_CASE("Create an adapter mode list", "[morpheus.gfx.d3d12.adapter_list]") {}
 
 TEST_CASE("Iterates over the adapters in the list", "[morpheus.gfx.d3d12.adapter_list]")
 {
     GIVEN("An adapter list")
     {
-        //adapter_list adapters;
+        // adapter_list adapters;
         THEN("Loop over all adapters using native for loop syntax")
         {
-        //    for (const auto& adapter : adapters)
-            {
-
-            }
+            //    for (const auto& adapter : adapters)
+            {}
         }
     }
 }

libraries/gfx/d3d12/tests/video_mode_list.tests.cpp

@@ -4,8 +4,6 @@
 namespace morpheus::gfx::d3d12
 {
 
-TEST_CASE("Create a video mode list", "[morpheus.gfx.d3d12.video_mode_list]")
-{
-}
+TEST_CASE("Create a video mode list", "[morpheus.gfx.d3d12.video_mode_list]") {}
 
 } // namespace morpheus::gfx::d3d12

libraries/gfx/gl4/tests/render_system.tests.cpp

@@ -1,5 +1,3 @@
 #include <catch2/catch_test_macros.hpp>
 
-TEST_CASE("Test the GL render system", "[morpheus.core.gfx.gl4.render_system]")
-{
-}
+TEST_CASE("Test the GL render system", "[morpheus.core.gfx.gl4.render_system]") {}

libraries/gfx/gl4/tests/wgl/adapter.tests.cpp

@@ -1,32 +1,29 @@
 #include <morpheus/gfx/gl4/wgl/adapter.hpp>
 #include <morpheus/gfx/platform/concepts/adapter.hpp>
-#include <catch2/catch_all.hpp>
-
-
 
+#include <catch2/catch_all.hpp>
 
 #include <morpheus/core/conformance/expected.hpp>
 #include <vector>
 
-#include <windows.h>
 #include <cfgmgr32.h>
+#include <windows.h>
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)
-//#error "Missing define"
+// #error "Missing define"
 #endif
 
 #include <devpkey.h>
 #include <setupapi.h>
 
-#include <initguid.h>
 #include <devpkey.h>
+#include <initguid.h>
 
 #include <Cfgmgr32.h>
 #include <Wiaintfc.h>
 
 #include <devguid.h>
-#include <winioctl.h>
 #include <rpc.h>
-
+#include <winioctl.h>
 
 /*
 #include <CL/cl.h>
@@ -35,7 +32,7 @@
 #include <string.h>
 */
 #ifdef _WIN32
-#include <windows.h>
+    #include <windows.h>
 extern "C" __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
 extern "C" __declspec(dllexport) DWORD AmdPowerXpressRequestHighPerformance = 0x00000001;
 #endif
@@ -72,25 +69,25 @@ exp_ns::expected<DisplayConfig, HRESULT> getCurrentDisplayConfig()
         if (rc != ERROR_INSUFFICIENT_BUFFER)
             return exp_ns::unexpected(rc);
     }
-    return DisplayConfig{ std::move(pathInfo), std::move(modeInfo) };
+    return DisplayConfig{std::move(pathInfo), std::move(modeInfo)};
 }
 
 TEST_CASE("Create an adapter mode list", "[morpheus.core.gfx.gl.wgl.adapter_list]")
 {
-//    DISPLAYCONFIG_ADAPTER_NAME adapter{ {DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME , sizeof(DISPLAYCONFIG_ADAPTER_NAME)} };
-//    MORPHEUS_VERIFY(DisplayConfigGetDeviceInfo(adapter.header) == ERROR_SUCCESS);
+    //    DISPLAYCONFIG_ADAPTER_NAME adapter{ {DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME , sizeof(DISPLAYCONFIG_ADAPTER_NAME)} };
+    //    MORPHEUS_VERIFY(DisplayConfigGetDeviceInfo(adapter.header) == ERROR_SUCCESS);
 
     LUID targetAdapter; // the LUID of the target we want to find the source for
-    ULONG targetId = 0;  // the id of the target we want to find the source for
+    ULONG targetId = 0; // the id of the target we want to find the source for
 
     DISPLAYCONFIG_ADAPTER_NAME adapterName = {};
-    adapterName.header.adapterId = LUID{68511,0}, //path.targetInfo.adapterId;
+    adapterName.header.adapterId = LUID{68511, 0}; // path.targetInfo.adapterId;
     adapterName.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME;
     adapterName.header.size = sizeof(adapterName);
     auto result2 = DisplayConfigGetDeviceInfo(&adapterName.header);
 
     DISPLAYCONFIG_ADAPTER_NAME adapterName2 = {};
-    adapterName2.header.adapterId = LUID{69333,0}, //path.targetInfo.adapterId;
+    adapterName2.header.adapterId = LUID{69333, 0}; // path.targetInfo.adapterId;
     adapterName2.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME;
     adapterName2.header.size = sizeof(adapterName2);
     auto result3 = DisplayConfigGetDeviceInfo(&adapterName2.header);
@@ -99,12 +96,11 @@ TEST_CASE("Create an adapter mode list", "[morpheus.core.gfx.gl.wgl.adapter_list
     ULONG PropertySize = 0;
     ULONG SomeValue = 0;
 
-
-    SP_DEVICE_INTERFACE_DATA interfaceData = { 0 };
+    SP_DEVICE_INTERFACE_DATA interfaceData = {0};
     interfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
-//    HDEVINFO deviceInfoSet = SetupDiCreateDeviceInfoList(NULL, NULL);
-//    SetupDiOpenDeviceInterface(deviceInfoSet, adapterName.adapterDevicePath, 0, &interfaceData);
+    //    HDEVINFO deviceInfoSet = SetupDiCreateDeviceInfoList(NULL, NULL);
+    //    SetupDiOpenDeviceInterface(deviceInfoSet, adapterName.adapterDevicePath, 0, &interfaceData);
     /*
     PropertySize = sizeof(SomeValue);
     auto cr = CM_Get_DevNode_PropertyW(DevInst,
@@ -121,12 +117,12 @@ TEST_CASE("Create an adapter mode list", "[morpheus.core.gfx.gl.wgl.adapter_list
 
     auto& [pathInfo, modeInfo] = result.value();
 
-    for (UINT32 tryEnable = 0;; ++tryEnable) {
+    for (UINT32 tryEnable = 0;; ++tryEnable)
+    {
         DISPLAYCONFIG_PATH_INFO* pCurrentPath = NULL;
         for (UINT32 i = 0, j = 0; i < pathInfo.size(); ++i)
         {
-            if (pathInfo[i].targetInfo.targetAvailable &&
-                !memcmp(&pathInfo[i].targetInfo.adapterId, &targetAdapter, sizeof(LUID)) &&
+            if (pathInfo[i].targetInfo.targetAvailable && !memcmp(&pathInfo[i].targetInfo.adapterId, &targetAdapter, sizeof(LUID)) &&
                 pathInfo[i].targetInfo.id == targetId)
             {
                 pathInfo[i].targetInfo.statusFlags |= DISPLAYCONFIG_TARGET_IN_USE;
@@ -153,7 +149,7 @@ TEST_CASE("Create an adapter mode list", "[morpheus.core.gfx.gl.wgl.adapter_list
             return; // failure. tried everything, apparently no source is connected to our target
 
         LONG rc = SetDisplayConfig(pathInfo.size(), pathInfo.data(), modeInfo.size(), modeInfo.data(),
-                    SDC_VALIDATE | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_ALLOW_CHANGES);
+                                   SDC_VALIDATE | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_ALLOW_CHANGES);
 
         if (rc != ERROR_SUCCESS)
         {
@@ -167,24 +163,24 @@ TEST_CASE("Create an adapter mode list", "[morpheus.core.gfx.gl.wgl.adapter_list
             break; // success!
         }
     }
-    //Note: pSource is pointing to the source relevant to the relevant source now!
-    //You just need to copy off whatever you need.
+    // Note: pSource is pointing to the source relevant to the relevant source now!
+    // You just need to copy off whatever you need.
 }
 
 TEST_CASE("Concept checks for WGL adapters", "[morpheus.gfx.gl.wgl.adapter.concepts]")
 {
-//    STATIC_REQUIRE(concepts::VideoMode<VideoMode>);
-    //STATIC_REQUIRE(requires(Adapter t) { { t.getName() } -> std::convertible_to<std::string_view>; });
-    //STATIC_REQUIRE(requires(Adapter t) { { t.getVideoModes() } -> morpheus::gfx::concepts::VideoModeRange; });
+    //    STATIC_REQUIRE(concepts::VideoMode<VideoMode>);
+    // STATIC_REQUIRE(requires(Adapter t) { { t.getName() } -> std::convertible_to<std::string_view>; });
+    // STATIC_REQUIRE(requires(Adapter t) { { t.getVideoModes() } -> morpheus::gfx::concepts::VideoModeRange; });
 
-//    STATIC_REQUIRE(gfx::concepts::Adapter<Adapter>);
+    //    STATIC_REQUIRE(gfx::concepts::Adapter<Adapter>);
 }
 
 TEST_CASE("Iterates over the adapters in the list", "[morpheus.core.gfx.gl.wgl.adapter_list]")
 {
     GIVEN("An adapter list")
     {
-        //adapter_list adapters;
+        // adapter_list adapters;
         THEN("Loop over all adapters using native for loop syntax")
         {
             for (auto& adapter : enumerateAdapters())
@@ -193,7 +189,6 @@ TEST_CASE("Iterates over the adapters in the list", "[morpheus.core.gfx.gl.wgl.a
             }
         }
     }
-
 }
 
 /*

libraries/gfx/gl4/tests/wgl/video_mode.tests.cpp

@@ -7,7 +7,7 @@ namespace morpheus::test
 
 TEST_CASE("Create a video mode list", "[morpheus.core.gfx.video_mode_list]")
 {
-//    INFO("The number is " << i);
+    //    INFO("The number is " << i);
 }
 
 } // namespace morpheus::test