tests: Improve tests for struct versions

Tests for current struct versions should fail when a header update provides newer struct versions.
Also slightly reorganize d3d tests.

3 files changed, 141 insertions, 38 deletions

diff --git a/tests/nvapi_d3d.cpp b/tests/nvapi_d3d.cpp
index 177b696..577d7d1 100644
--- a/tests/nvapi_d3d.cpp
+++ b/tests/nvapi_d3d.cpp
@@ -52,11 +52,18 @@ TEST_CASE("D3D methods succeed", "[.d3d]") {
             REQUIRE(state.numVRSLIGpus == 0);
         }
 
-        SECTION("GetCurrentSLIState with future struct version returns incompatible-struct-version") {
+        SECTION("GetCurrentSLIState with unknown struct version returns incompatible-struct-version") {
             NV_GET_CURRENT_SLI_STATE state;
             state.version = NV_GET_CURRENT_SLI_STATE_VER2 + 1;
             REQUIRE(NvAPI_D3D_GetCurrentSLIState(&unknown, &state) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
         }
+
+        SECTION("GetCurrentSLIState with current struct version returns not incompatible-struct-version") {
+            // This test fails when a header update provides a newer not yet implemented struct version
+            NV_GET_CURRENT_SLI_STATE state;
+            state.version = NV_GET_CURRENT_SLI_STATE_VER;
+            REQUIRE(NvAPI_D3D_GetCurrentSLIState(&unknown, &state) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+        }
     }
 
     SECTION("ImplicitSLIControl succeeds") {
@@ -87,13 +94,20 @@ TEST_CASE("D3D methods succeed", "[.d3d]") {
             REQUIRE(caps.bVariablePixelRateShadingSupported == 0);
         }
 
-        SECTION("GetGraphicsCapabilities with future struct version returns incompatible-struct-version") {
+        SECTION("GetGraphicsCapabilities with unknown struct version returns incompatible-struct-version") {
             NV_D3D1x_GRAPHICS_CAPS caps;
             REQUIRE(NvAPI_D3D1x_GetGraphicsCapabilities(&unknown, NV_D3D1x_GRAPHICS_CAPS_VER2 + 1, &caps) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
         }
+
+        SECTION("GetGraphicsCapabilities with current struct version returns not incompatible-struct-version") {
+            // This test should fail when a header update provides a newer not yet implemented struct version
+            NV_D3D1x_GRAPHICS_CAPS caps;
+            REQUIRE(NvAPI_D3D1x_GetGraphicsCapabilities(&unknown, NV_D3D1x_GRAPHICS_CAPS_VER, &caps) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+        }
     }
 }
-TEST_CASE("Reflex methods", "[.d3d]"){
+
+TEST_CASE("D3D Reflex/LatencyFleX depending methods succeed", "[.d3d]"){
     UnknownMock unknown;
     auto dxgiFactory = std::make_unique<DXGIFactory1Mock>();
     auto vulkan = std::make_unique<VulkanMock>();
@@ -104,68 +118,101 @@ TEST_CASE("Reflex methods", "[.d3d]"){
 
     auto e = ConfigureDefaultTestEnvironment(*dxgiFactory, *vulkan, *nvml, *lfx, adapter, output);
 
-    SECTION("LatencyFleX-depending methods return NoImplementation when LFX is unavailable") {
-        SECTION("GetSleepStatus returns NoImplementation") {
+    ALLOW_CALL(*lfx, IsAvailable())
+        .RETURN(false);
+
+    SECTION("Reflex methods succeed when LFX is available") {
+        ALLOW_CALL(*lfx, IsAvailable())
+            .RETURN(true); // NOLINT(bugprone-use-after-move)
+
+        SECTION("GetSleepStatus returns OK") {
             SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
             REQUIRE(NvAPI_Initialize() == NVAPI_OK);
 
-            NV_GET_SLEEP_STATUS_PARAMS params{};
-            params.version = NV_GET_SLEEP_STATUS_PARAMS_VER;
-            REQUIRE(NvAPI_D3D_GetSleepStatus(&unknown, &params) == NVAPI_NO_IMPLEMENTATION);
+            NV_GET_SLEEP_STATUS_PARAMS_V1 params{};
+            params.version = NV_GET_SLEEP_STATUS_PARAMS_VER1;
+            REQUIRE(NvAPI_D3D_GetSleepStatus(&unknown, &params) == NVAPI_OK);
         }
 
-        SECTION("SetSleepMode returns NoImplementation") {
+        SECTION("SetSleepMode returns OK") {
+            REQUIRE_CALL(*lfx, SetTargetFrameTime(250ULL * 1000)); // NOLINT(bugprone-use-after-move)
+
             SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
             REQUIRE(NvAPI_Initialize() == NVAPI_OK);
 
-            NV_SET_SLEEP_MODE_PARAMS params{};
-            params.version = NV_SET_SLEEP_MODE_PARAMS_VER;
+            NV_SET_SLEEP_MODE_PARAMS_V1 params{};
+            params.version = NV_SET_SLEEP_MODE_PARAMS_VER1;
             params.bLowLatencyMode = true;
-            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) == NVAPI_NO_IMPLEMENTATION);
+            params.minimumIntervalUs = 250;
+            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) == NVAPI_OK);
         }
 
-        SECTION("Sleep returns NoImplementation") {
+        SECTION("Sleep calls LFX throttle callback and returns OK") {
+            REQUIRE_CALL(*lfx, SetTargetFrameTime(500ULL * 1000)); // NOLINT(bugprone-use-after-move)
+            REQUIRE_CALL(*lfx, WaitAndBeginFrame());
+
             SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
             REQUIRE(NvAPI_Initialize() == NVAPI_OK);
 
-            REQUIRE(NvAPI_D3D_Sleep(&unknown) == NVAPI_NO_IMPLEMENTATION);
+            NV_SET_SLEEP_MODE_PARAMS params{};
+            params.version = NV_SET_SLEEP_MODE_PARAMS_VER;
+            params.bLowLatencyMode = true;
+            params.minimumIntervalUs = 500;
+            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) == NVAPI_OK);
+            REQUIRE(NvAPI_D3D_Sleep(&unknown) == NVAPI_OK);
         }
-    }
-    
-    SECTION("Reflex methods work when LFX is available") {
-        ALLOW_CALL(*lfx, IsAvailable()).RETURN(true); // NOLINT(bugprone-use-after-move)
 
-        SECTION("GetSleepStatus returns OK") {
+        SECTION("GetSleepStatus with unknown struct version returns incompatible-struct-version") {
+            NV_GET_SLEEP_STATUS_PARAMS params{};
+            params.version = NV_GET_SLEEP_STATUS_PARAMS_VER1 + 1;
+            REQUIRE(NvAPI_D3D_GetSleepStatus(&unknown, &params) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+        }
+
+        SECTION("GetSleepStatus with current struct version returns not incompatible-struct-version") {
+            // This test should fail when a header update provides a newer not yet implemented struct version
             SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
             REQUIRE(NvAPI_Initialize() == NVAPI_OK);
 
             NV_GET_SLEEP_STATUS_PARAMS params{};
             params.version = NV_GET_SLEEP_STATUS_PARAMS_VER;
-            REQUIRE(NvAPI_D3D_GetSleepStatus(&unknown, &params) == NVAPI_OK);
+            REQUIRE(NvAPI_D3D_GetSleepStatus(&unknown, &params) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
         }
 
-        SECTION("SetSleepMode returns OK") {
-            REQUIRE_CALL(*lfx, SetTargetFrameTime(UINT64_C(0))); // NOLINT(bugprone-use-after-move)
+        SECTION("SetSleepMode with unknown struct version returns incompatible-struct-version") {
+            NV_SET_SLEEP_MODE_PARAMS params{};
+            params.version = NV_SET_SLEEP_MODE_PARAMS_VER1 + 1;
+            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+        }
+
+        SECTION("SetSleepMode with current struct version returns not incompatible-struct-version") {
+            // This test should fail when a header update provides a newer not yet implemented struct version
             SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
             REQUIRE(NvAPI_Initialize() == NVAPI_OK);
 
             NV_SET_SLEEP_MODE_PARAMS params{};
             params.version = NV_SET_SLEEP_MODE_PARAMS_VER;
-            params.bLowLatencyMode = true;
-            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) == NVAPI_OK);
+            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
         }
+    }
 
-        SECTION("Sleep calls LFX throttle callback and returns OK") {
-            REQUIRE_CALL(*lfx, SetTargetFrameTime(UINT64_C(0))); // NOLINT(bugprone-use-after-move)
-            REQUIRE_CALL(*lfx, WaitAndBeginFrame());
-            SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
-            REQUIRE(NvAPI_Initialize() == NVAPI_OK);
+    SECTION("LatencyFleX depending methods succeed when LFX is unavailable") {
+        SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
+        REQUIRE(NvAPI_Initialize() == NVAPI_OK);
+
+        SECTION("GetSleepStatus returns NoImplementation") {
+            NV_GET_SLEEP_STATUS_PARAMS params{};
+            params.version = NV_GET_SLEEP_STATUS_PARAMS_VER;
+            REQUIRE(NvAPI_D3D_GetSleepStatus(&unknown, &params) == NVAPI_NO_IMPLEMENTATION);
+        }
 
+        SECTION("SetSleepMode returns NoImplementation") {
             NV_SET_SLEEP_MODE_PARAMS params{};
             params.version = NV_SET_SLEEP_MODE_PARAMS_VER;
-            params.bLowLatencyMode = true;
-            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) == NVAPI_OK);
-            REQUIRE(NvAPI_D3D_Sleep(&unknown) == NVAPI_OK);
+            REQUIRE(NvAPI_D3D_SetSleepMode(&unknown, &params) == NVAPI_NO_IMPLEMENTATION);
+        }
+
+        SECTION("Sleep returns NoImplementation") {
+            REQUIRE(NvAPI_D3D_Sleep(&unknown) == NVAPI_NO_IMPLEMENTATION);
         }
     }
 }
diff --git a/tests/nvapi_d3d12.cpp b/tests/nvapi_d3d12.cpp
index 5d3b140..abc3d9c 100644
--- a/tests/nvapi_d3d12.cpp
+++ b/tests/nvapi_d3d12.cpp
@@ -192,7 +192,7 @@ TEST_CASE("D3D12 methods succeed", "[.d3d12]") {
             ::SetEnvironmentVariableA("DXVK_NVAPI_ALLOW_OTHER_DRIVERS", "");
         }
 
-        SECTION("GetGraphicsCapabilities with future struct version returns incompatible-struct-version") {
+        SECTION("GetGraphicsCapabilities with unknown struct version returns incompatible-struct-version") {
             SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
             REQUIRE(NvAPI_Initialize() == NVAPI_OK);
 
@@ -200,6 +200,15 @@ TEST_CASE("D3D12 methods succeed", "[.d3d12]") {
             REQUIRE(NvAPI_D3D12_GetGraphicsCapabilities(static_cast<ID3D12Device*>(&device), NV_D3D12_GRAPHICS_CAPS_VER1 + 1, &graphicsCaps) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
         }
 
+        SECTION("GetGraphicsCapabilities with current struct version returns not incompatible-struct-version") {
+            // This test should fail when a header update provides a newer not yet implemented struct version
+            SetupResourceFactory(std::move(dxgiFactory), std::move(vulkan), std::move(nvml), std::move(lfx));
+            REQUIRE(NvAPI_Initialize() == NVAPI_OK);
+
+            NV_D3D12_GRAPHICS_CAPS graphicsCaps{};
+            REQUIRE(NvAPI_D3D12_GetGraphicsCapabilities(static_cast<ID3D12Device*>(&device), NV_D3D12_GRAPHICS_CAPS_VER, &graphicsCaps) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+        }
+
         delete luid;
     }
 
@@ -222,7 +231,7 @@ TEST_CASE("D3D12 methods succeed", "[.d3d12]") {
             REQUIRE(commandListRefCount == 0);
         }
 
-        SECTION("CreateGraphicsPipelineState with future struct version returns incompatible-struct-version") {
+        SECTION("CreateGraphicsPipelineState with unknown struct version returns incompatible-struct-version") {
             auto desc = D3D12_GRAPHICS_PIPELINE_STATE_DESC{};
             NVAPI_D3D12_PSO_ENABLE_DEPTH_BOUND_TEST_DESC extensionDesc;
             extensionDesc.baseVersion = NV_PSO_EXTENSION_DESC_VER_1 + 1;
@@ -230,6 +239,19 @@ TEST_CASE("D3D12 methods succeed", "[.d3d12]") {
             ID3D12PipelineState* pipelineState = nullptr;
             REQUIRE(NvAPI_D3D12_CreateGraphicsPipelineState(&device, &desc, 1, extensions, &pipelineState) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
         }
+
+        SECTION("CreateGraphicsPipelineState with current struct version returns not incompatible-struct-version") {
+            // This test should fail when a header update provides a newer not yet implemented struct version
+            ALLOW_CALL(device, CreateGraphicsPipelineState(_, _, _))
+                .RETURN(S_OK);
+
+            auto desc = D3D12_GRAPHICS_PIPELINE_STATE_DESC{};
+            NVAPI_D3D12_PSO_ENABLE_DEPTH_BOUND_TEST_DESC extensionDesc;
+            extensionDesc.baseVersion = NV_PSO_EXTENSION_DESC_VER;
+            const NVAPI_D3D12_PSO_EXTENSION_DESC* extensions[] = { &extensionDesc };
+            ID3D12PipelineState* pipelineState = nullptr;
+            REQUIRE(NvAPI_D3D12_CreateGraphicsPipelineState(&device, &desc, 1, extensions, &pipelineState) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+        }
     }
 
     SECTION("SetDepthBoundsTestValues returns OK") {
diff --git a/tests/nvapi_sysinfo.cpp b/tests/nvapi_sysinfo.cpp
index 99f2614..056fb26 100644
--- a/tests/nvapi_sysinfo.cpp
+++ b/tests/nvapi_sysinfo.cpp
@@ -667,7 +667,7 @@ TEST_CASE("Sysinfo methods succeed", "[.sysinfo]") {
         }
     }
 
-    SECTION("GetArchInfo with future struct version returns incompatible-struct-version") {
+    SECTION("GetArchInfo with unknown struct version returns incompatible-struct-version") {
         NvPhysicalGpuHandle handle;
         REQUIRE(NvAPI_SYS_GetPhysicalGpuFromDisplayId(0, &handle) == NVAPI_OK);
 
@@ -676,6 +676,16 @@ TEST_CASE("Sysinfo methods succeed", "[.sysinfo]") {
         REQUIRE(NvAPI_GPU_GetArchInfo(handle, &archInfo) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
     }
 
+    SECTION("GetArchInfo with current struct version returns not incompatible-struct-version") {
+        // This test should fail when a header update provides a newer not yet implemented struct version
+        NvPhysicalGpuHandle handle;
+        REQUIRE(NvAPI_SYS_GetPhysicalGpuFromDisplayId(0, &handle) == NVAPI_OK);
+
+        NV_GPU_ARCH_INFO archInfo;
+        archInfo.version = NV_GPU_ARCH_INFO_VER;
+        REQUIRE(NvAPI_GPU_GetArchInfo(handle, &archInfo) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+    }
+
     SECTION("GetArchInfo returns device-not-found when no NVIDIA device is present") {
         ::SetEnvironmentVariableA("DXVK_NVAPI_ALLOW_OTHER_DRIVERS", "1");
 
@@ -807,11 +817,18 @@ TEST_CASE("Sysinfo methods succeed", "[.sysinfo]") {
                 REQUIRE(settings.sensor[0].defaultMinTemp == -256);
             }
 
-            SECTION("GetThermalSettings with future struct version returns incompatible-struct-version") {
+            SECTION("GetThermalSettings with unknown struct version returns incompatible-struct-version") {
                 NV_GPU_THERMAL_SETTINGS settings;
                 settings.version = NV_GPU_THERMAL_SETTINGS_VER_2 + 1;
                 REQUIRE(NvAPI_GPU_GetThermalSettings(handle, NVAPI_THERMAL_TARGET_ALL, &settings) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
             }
+
+            SECTION("GetThermalSettings with current struct version returns not incompatible-struct-version") {
+                // This test should fail when a header update provides a newer not yet implemented struct version
+                NV_GPU_THERMAL_SETTINGS settings;
+                settings.version = NV_GPU_THERMAL_SETTINGS_VER;
+                REQUIRE(NvAPI_GPU_GetThermalSettings(handle, NVAPI_THERMAL_TARGET_ALL, &settings) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+            }
         }
 
         SECTION("GetCurrentPstate returns OK") {
@@ -889,7 +906,7 @@ TEST_CASE("Sysinfo methods succeed", "[.sysinfo]") {
             }
         }
 
-        SECTION("GetAllClockFrequencies with future struct version returns incompatible-struct-version") {
+        SECTION("GetAllClockFrequencies with unknown struct version returns incompatible-struct-version") {
             NvPhysicalGpuHandle handle;
             REQUIRE(NvAPI_SYS_GetPhysicalGpuFromDisplayId(0, &handle) == NVAPI_OK);
 
@@ -898,6 +915,16 @@ TEST_CASE("Sysinfo methods succeed", "[.sysinfo]") {
             REQUIRE(NvAPI_GPU_GetAllClockFrequencies(handle, &frequencies) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
         }
 
+        SECTION("GetAllClockFrequencies with current struct version returns not incompatible-struct-version") {
+            // This test should fail when a header update provides a newer not yet implemented struct version
+            NvPhysicalGpuHandle handle;
+            REQUIRE(NvAPI_SYS_GetPhysicalGpuFromDisplayId(0, &handle) == NVAPI_OK);
+
+            NV_GPU_CLOCK_FREQUENCIES frequencies;
+            frequencies.version = NV_GPU_CLOCK_FREQUENCIES_VER;
+            REQUIRE(NvAPI_GPU_GetAllClockFrequencies(handle, &frequencies) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+        }
+
         SECTION("GetAllClockFrequencies returns not-supported for base/boost clock types") {
             struct Data {NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE clockType;};
             auto args = GENERATE(
@@ -1016,11 +1043,18 @@ TEST_CASE("GetHdrCapabilities succeeds", "[.sysinfo]") {
         REQUIRE(capabilities.isDolbyVisionSupported == false);
     }
 
-    SECTION("GetHdrCapabilities with future struct version returns incompatible-struct-version") {
+    SECTION("GetHdrCapabilities with unknown struct version returns incompatible-struct-version") {
         NV_HDR_CAPABILITIES capabilities;
         capabilities.version = NV_HDR_CAPABILITIES_VER2 + 1;
         REQUIRE(NvAPI_Disp_GetHdrCapabilities(0, &capabilities) == NVAPI_INCOMPATIBLE_STRUCT_VERSION);
     }
+
+    SECTION("GetHdrCapabilities with current struct version returns not incompatible-struct-version") {
+        // This test should fail when a header update provides a newer not yet implemented struct version
+        NV_HDR_CAPABILITIES capabilities;
+        capabilities.version = NV_HDR_CAPABILITIES_VER;
+        REQUIRE(NvAPI_Disp_GetHdrCapabilities(0, &capabilities) != NVAPI_INCOMPATIBLE_STRUCT_VERSION);
+    }
 }
 
 TEST_CASE("GetDisplayViewportsByResolution returns mosaic-not-active", "[.sysinfo]") {