Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDKHEADmain

1 files changed, 1354 insertions, 0 deletions

diff --git a/contrib/DirectX-Headers-1.618.2/googletest/feature_support_test.cpp b/contrib/DirectX-Headers-1.618.2/googletest/feature_support_test.cpp
new file mode 100644
index 0000000..0394384
--- /dev/null
+++ b/contrib/DirectX-Headers-1.618.2/googletest/feature_support_test.cpp
@@ -0,0 +1,1354 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "gtest/gtest.h"
+
+#include <wsl/winadapter.h>
+
+#include <directx/d3d12.h>
+#include <directx/dxcore.h>
+#include <directx/d3dx12.h>
+#include "dxguids/dxguids.h"
+
+#include "MockDevice.hpp"
+
+// Initiliaze the CD3DX12FeatureSupport instance
+// Can be modified to use new initialization methods if any comes up in the future
+#define INIT_FEATURES() \
+    CD3DX12FeatureSupport features; \
+    HRESULT InitResult = features.Init(device); \
+    EXPECT_EQ(features.GetStatus(), S_OK);
+
+// Testing class setup
+class FeatureSupportTest : public ::testing::Test {
+protected: 
+    void SetUp() override {
+        device = new MockDevice(1);
+    }
+
+    void TearDown() override {
+        delete device;
+    }
+
+    MockDevice* device = nullptr;
+};
+
+// Test if the class can be initialized correctly
+TEST_F(FeatureSupportTest, Initialization) {
+    CD3DX12FeatureSupport features;
+    EXPECT_EQ(features.Init(device), S_OK);
+    EXPECT_EQ(features.GetStatus(), S_OK);
+}
+
+// 0: D3D12_OPTIONS
+// Arbitarily set support status for caps and see if the returned results are correct
+TEST_F(FeatureSupportTest, D3D12Options) {
+    device->m_DoublePrecisionFloatShaderOps = true;
+    device->m_OutputMergerLogicOp = true;
+    device->m_ShaderMinPrecisionSupport10Bit = D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT;
+    device->m_ShaderMinPrecisionSupport16Bit = D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT;
+    device->m_TiledResourcesTier = D3D12_TILED_RESOURCES_TIER_3;
+    device->m_ResourceBindingTier = D3D12_RESOURCE_BINDING_TIER_3;
+    device->m_PSSpecifiedStencilRefSupported = true;
+    device->m_ConservativeRasterizationTier = D3D12_CONSERVATIVE_RASTERIZATION_TIER_2;
+    device->m_MaxGPUVirtualAddressBitsPerResource = 10;
+    device->m_ResourceHeapTier = D3D12_RESOURCE_HEAP_TIER_2;
+
+    INIT_FEATURES();
+    EXPECT_TRUE(features.DoublePrecisionFloatShaderOps());
+    EXPECT_TRUE(features.OutputMergerLogicOp());
+    EXPECT_EQ(features.MinPrecisionSupport(), D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT | D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT);
+    EXPECT_EQ(features.TiledResourcesTier(), D3D12_TILED_RESOURCES_TIER_3);
+    EXPECT_EQ(features.ResourceBindingTier(), D3D12_RESOURCE_BINDING_TIER_3);
+    EXPECT_TRUE(features.PSSpecifiedStencilRefSupported());
+    EXPECT_FALSE(features.TypedUAVLoadAdditionalFormats());
+    EXPECT_FALSE(features.ROVsSupported());
+    EXPECT_EQ(features.ConservativeRasterizationTier(), D3D12_CONSERVATIVE_RASTERIZATION_TIER_2);
+    EXPECT_EQ(features.MaxGPUVirtualAddressBitsPerResource(), 10);
+    EXPECT_FALSE(features.StandardSwizzle64KBSupported());
+    EXPECT_EQ(features.CrossNodeSharingTier(), D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED);
+    EXPECT_FALSE(features.CrossAdapterRowMajorTextureSupported());
+    EXPECT_FALSE(features.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation());
+    EXPECT_EQ(features.ResourceHeapTier(), D3D12_RESOURCE_HEAP_TIER_2);
+}
+
+// 1: Architecture & 16: Architecture1
+// Test where architecture1 is available
+TEST_F(FeatureSupportTest, Architecture1Available)
+{
+    device->m_Architecture1Available = true;
+    device->m_TileBasedRenderer[0] = false;
+    device->m_UMA[0] = true;
+    device->m_CacheCoherentUMA[0] = true;
+    device->m_IsolatedMMU[0] = true;
+
+    INIT_FEATURES();
+    EXPECT_FALSE(features.TileBasedRenderer(0));
+    EXPECT_TRUE(features.UMA(0));
+    EXPECT_TRUE(features.CacheCoherentUMA(0));
+    EXPECT_TRUE(features.IsolatedMMU(0));
+}
+
+// Test where architecture1 is not available
+TEST_F(FeatureSupportTest, Architecture1Unavailable)
+{
+    device->m_Architecture1Available = false; // Architecture1 not available
+    device->m_TileBasedRenderer[0] = false;
+    device->m_UMA[0] = true;
+    device->m_CacheCoherentUMA[0] = false;
+    device->m_IsolatedMMU[0] = true; // Notice that if architecture1 is not available, IslatedMMU cap should not be present
+
+    INIT_FEATURES();
+    EXPECT_FALSE(features.TileBasedRenderer(0));
+    EXPECT_TRUE(features.UMA(0));
+    EXPECT_FALSE(features.CacheCoherentUMA(0));
+    EXPECT_FALSE(features.IsolatedMMU(0)); // If Architecture1 is not available, IsolatedMMU should not be available
+}
+
+// Test on devices with more than one graphics node
+TEST_F(FeatureSupportTest, ArchitectureMultinode)
+{
+    device->SetNodeCount(3);
+    device->m_Architecture1Available = true;
+    device->m_TileBasedRenderer = {false, true, true};
+    device->m_UMA = {true, false, false};
+    device->m_CacheCoherentUMA = {false, false, true};
+    device->m_IsolatedMMU = {false, true, false};
+
+    INIT_FEATURES();
+    
+    EXPECT_FALSE(features.TileBasedRenderer(0));
+    EXPECT_TRUE(features.TileBasedRenderer(1));
+    EXPECT_TRUE(features.TileBasedRenderer(2));
+    
+    EXPECT_TRUE(features.UMA(0));
+    EXPECT_FALSE(features.UMA(1));
+    EXPECT_FALSE(features.UMA(2));
+
+    EXPECT_FALSE(features.CacheCoherentUMA(0));
+    EXPECT_FALSE(features.CacheCoherentUMA(1));
+    EXPECT_TRUE(features.CacheCoherentUMA(2));
+
+    EXPECT_FALSE(features.IsolatedMMU(0));
+    EXPECT_TRUE(features.IsolatedMMU(1));
+    EXPECT_FALSE(features.IsolatedMMU(2));
+}
+
+// 2: Feature Levels
+// Basic test with a high feature level
+TEST_F(FeatureSupportTest, FeatureLevelBasic)
+{
+    device->m_FeatureLevel = D3D_FEATURE_LEVEL_12_2;
+    
+    INIT_FEATURES();
+    EXPECT_EQ(features.MaxSupportedFeatureLevel(), D3D_FEATURE_LEVEL_12_2);
+}
+
+// Test through all supported feature levels
+TEST_F(FeatureSupportTest, FeatureLevelAll)
+{
+    std::vector<D3D_FEATURE_LEVEL> allLevels = 
+    {
+        D3D_FEATURE_LEVEL_1_0_CORE,
+        D3D_FEATURE_LEVEL_9_1,
+        D3D_FEATURE_LEVEL_9_2,
+        D3D_FEATURE_LEVEL_9_3,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_11_1,
+        D3D_FEATURE_LEVEL_12_0,
+        D3D_FEATURE_LEVEL_12_1,
+        D3D_FEATURE_LEVEL_12_2
+    };
+
+    for (unsigned int i = 0; i < allLevels.size(); i++) 
+    {
+        device->m_FeatureLevel = allLevels[i];
+        INIT_FEATURES();
+        EXPECT_EQ(features.MaxSupportedFeatureLevel(), allLevels[i]);
+    }
+}
+
+// Test with a feature level higher than the current highest level
+TEST_F(FeatureSupportTest, FeatureLevelHigher)
+{
+    device->m_FeatureLevel = (D3D_FEATURE_LEVEL)(D3D_FEATURE_LEVEL_12_2 + 1);
+    INIT_FEATURES();
+    EXPECT_EQ(features.MaxSupportedFeatureLevel(), D3D_FEATURE_LEVEL_12_2);
+}
+
+// 3: Format Support
+// Forward call to the old API. Basic correctness check
+// Note: The input and return value of this test is arbitrary and does not reflect the results of running on real devices
+// The test only checks if the input and output are correctly passed to the inner API and the user.
+// Same applies to Multisample Quality Levels (4) and Format Info (5)
+TEST_F(FeatureSupportTest, FormatSupportPositive)
+{
+    device->m_FormatSupport1 = D3D12_FORMAT_SUPPORT1_BUFFER | D3D12_FORMAT_SUPPORT1_TEXTURE3D | D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON | D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT;
+    device->m_FormatSupport2 = D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD | D3D12_FORMAT_SUPPORT2_TILED;
+
+    INIT_FEATURES();
+
+    D3D12_FORMAT_SUPPORT1 support1;
+    D3D12_FORMAT_SUPPORT2 support2;
+
+    HRESULT result = features.FormatSupport(DXGI_FORMAT_R32G32_UINT, support1, support2); // Some random input
+    EXPECT_EQ(support1, D3D12_FORMAT_SUPPORT1_BUFFER | D3D12_FORMAT_SUPPORT1_TEXTURE3D | D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON | D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT);
+    EXPECT_EQ(support2, D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD | D3D12_FORMAT_SUPPORT2_TILED);
+    EXPECT_EQ(result, S_OK);
+}
+
+// Negative test
+TEST_F(FeatureSupportTest, FormatSupportNegative)
+{
+    device->m_FormatSupport1 = D3D12_FORMAT_SUPPORT1_NONE;
+    device->m_FormatSupport2 = D3D12_FORMAT_SUPPORT2_NONE;
+    INIT_FEATURES();
+
+    D3D12_FORMAT_SUPPORT1 support1;
+    D3D12_FORMAT_SUPPORT2 support2;
+
+    HRESULT result = features.FormatSupport(DXGI_FORMAT_UNKNOWN, support1, support2);
+    EXPECT_EQ(support1, D3D12_FORMAT_SUPPORT1_NONE);
+    EXPECT_EQ(support2, D3D12_FORMAT_SUPPORT2_NONE);
+    EXPECT_EQ(result, E_FAIL);
+}
+
+// 4: Multisample Quality Levels
+// Forwarding call. Check if the API received the correct information.
+TEST_F(FeatureSupportTest, MultisampleQualityLevelsPositive)
+{
+    device->m_NumQualityLevels = 42; // Arbitrary return value
+    
+    INIT_FEATURES();
+
+    DXGI_FORMAT inFormat = DXGI_FORMAT_R16G16B16A16_FLOAT;
+    UINT inSampleCount = 10;
+    D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS inFlags = D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE;
+    UINT NumQualityLevels;
+    
+    HRESULT result = features.MultisampleQualityLevels(inFormat, inSampleCount, inFlags, NumQualityLevels);
+
+    EXPECT_EQ(device->m_FormatReceived, inFormat);
+    EXPECT_EQ(device->m_SampleCountReceived, inSampleCount);
+    EXPECT_EQ(device->m_MultisampleQualityLevelFlagsReceived, inFlags);
+    EXPECT_EQ(result, S_OK);
+    EXPECT_EQ(NumQualityLevels, 42);
+}
+
+// Test where the feature check fails
+TEST_F(FeatureSupportTest, MultisampleQualityLevelsNegative)
+{
+    device->m_NumQualityLevels = 42;
+    device->m_MultisampleQualityLevelsSucceed = false; // Simulate failure
+
+    INIT_FEATURES();
+
+    DXGI_FORMAT inFormat = DXGI_FORMAT_R16G16B16A16_FLOAT;
+    UINT inSampleCount = 6;
+    D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS inFlags = D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE;
+    UINT NumQualityLevels;
+    
+    HRESULT result = features.MultisampleQualityLevels(inFormat, inSampleCount, inFlags, NumQualityLevels);
+
+    EXPECT_EQ(device->m_FormatReceived, inFormat);
+    EXPECT_EQ(device->m_SampleCountReceived, inSampleCount);
+    EXPECT_EQ(device->m_MultisampleQualityLevelFlagsReceived, inFlags);
+    EXPECT_EQ(result, E_FAIL);
+    EXPECT_EQ(NumQualityLevels, 0);
+}
+
+// 5: Format Info
+// Forward call to old API. Basic check
+TEST_F(FeatureSupportTest, FormatInfoPositive)
+{
+    device->m_PlaneCount = 4;
+
+    INIT_FEATURES();
+
+    DXGI_FORMAT inFormat = DXGI_FORMAT_D32_FLOAT;
+    UINT8 PlaneCount;
+    HRESULT result = features.FormatInfo(inFormat, PlaneCount);
+
+    EXPECT_EQ(PlaneCount, 4);
+    EXPECT_EQ(result, S_OK);
+    EXPECT_EQ(device->m_FormatReceived, inFormat);
+}
+
+// Test when feature check fails
+TEST_F(FeatureSupportTest, FormatInfoNegative)
+{
+    device->m_PlaneCount = 6;
+    device->m_DXGIFormatSupported = false;
+
+    INIT_FEATURES();
+
+    DXGI_FORMAT inFormat = DXGI_FORMAT_BC1_UNORM;
+    UINT8 PlaneCount;
+    HRESULT result = features.FormatInfo(inFormat, PlaneCount);
+
+    EXPECT_EQ(result, E_INVALIDARG);
+    EXPECT_EQ(PlaneCount, 0);
+    EXPECT_EQ(device->m_FormatReceived, inFormat);
+}
+
+// 6: GPUVA Support
+TEST_F(FeatureSupportTest, GPUVASupport)
+{
+    device->m_MaxGPUVirtualAddressBitsPerProcess = 16;
+    device->m_MaxGPUVirtualAddressBitsPerResource = 12;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.MaxGPUVirtualAddressBitsPerProcess(), 16);
+    EXPECT_EQ(features.MaxGPUVirtualAddressBitsPerResource(), 12);
+}
+
+/*
+    Starting from Options1, all features should have an "unavailable test"
+    to ensure the new API returns the desired default values
+    when a device does not support that feature
+*/
+
+// 8: Options1
+// Basic tests
+TEST_F(FeatureSupportTest, Options1Basic)
+{
+    device->m_WaveOpsSupported = true;
+    device->m_WaveLaneCountMin = 2;
+    device->m_WaveLaneCountMax = 4;
+    device->m_TotalLaneCount = 8;
+    device->m_ExpandedComputeResourceStates = true;
+    device->m_Int64ShaderOpsSupported = true;
+
+    INIT_FEATURES();
+    
+    EXPECT_TRUE(features.WaveOps());
+    EXPECT_EQ(features.WaveLaneCountMin(), 2);
+    EXPECT_EQ(features.WaveLaneCountMax(), 4);
+    EXPECT_EQ(features.TotalLaneCount(), 8);
+    EXPECT_TRUE(features.ExpandedComputeResourceStates());
+    EXPECT_TRUE(features.Int64ShaderOps());
+}
+
+// Unavailable test
+// Test where device does not support Options1
+TEST_F(FeatureSupportTest, Options1Unavailable)
+{
+    device->m_Options1Available = false;
+    device->m_WaveOpsSupported = true;
+    device->m_WaveLaneCountMin = 2;
+    device->m_WaveLaneCountMax = 4;
+    device->m_TotalLaneCount = 8;
+    device->m_ExpandedComputeResourceStates = true;
+    device->m_Int64ShaderOpsSupported = true;
+
+    INIT_FEATURES();
+
+    EXPECT_FALSE(features.WaveOps());
+    EXPECT_EQ(features.WaveLaneCountMin(), 0);
+    EXPECT_EQ(features.WaveLaneCountMax(), 0);
+    EXPECT_EQ(features.TotalLaneCount(), 0);
+    EXPECT_FALSE(features.ExpandedComputeResourceStates());
+    EXPECT_FALSE(features.Int64ShaderOps());
+}
+
+// 10: Protected Resource Session Support
+// Basic test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionSupportBasic)
+{
+    device->m_ProtectedResourceSessionSupport[0] = D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(0), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED);
+}
+
+// Negative test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionSupportNegative)
+{
+    device->m_ProtectedResourceSessionSupport[0] = D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED;
+    device->m_ContentProtectionSupported = false;
+
+    INIT_FEATURES();
+    
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+}
+
+// Multinode test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionSupportMultinode)
+{
+    device->SetNodeCount(4);
+    device->m_ProtectedResourceSessionSupport =
+    {
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE
+    };
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(0), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(1), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED);
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(2), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED);
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(3), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+}
+
+// Unavailable test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionSupportNotAvailable)
+{
+    device->m_ProtectedResourceSessionAvailable = false;
+    device->m_ProtectedResourceSessionSupport[0] = D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(0), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+}
+
+
+// Multinode Unavailable test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionSupportNotAvailableMultinode)
+{
+    device->m_ProtectedResourceSessionAvailable = false;
+    device->SetNodeCount(4);
+    device->m_ProtectedResourceSessionSupport =
+    {
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE
+    };
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(0), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(1), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(2), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(3), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+}
+
+// 12: Root Signature
+// Basic test (highest supported version in header)
+TEST_F(FeatureSupportTest, RootSignatureBasic)
+{
+    device->m_RootSignatureHighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1;
+    INIT_FEATURES();
+    EXPECT_EQ(features.HighestRootSignatureVersion(), D3D_ROOT_SIGNATURE_VERSION_1_1);
+}
+
+// Lower version test
+TEST_F(FeatureSupportTest, RootSignatureLower)
+{
+    device->m_RootSignatureHighestVersion = D3D_ROOT_SIGNATURE_VERSION_1;
+    INIT_FEATURES();
+    EXPECT_EQ(features.HighestRootSignatureVersion(), D3D_ROOT_SIGNATURE_VERSION_1);
+}
+
+// Higher version test
+TEST_F(FeatureSupportTest, RootSignatureHigher)
+{
+    device->m_RootSignatureHighestVersion = (D3D_ROOT_SIGNATURE_VERSION)(D3D_ROOT_SIGNATURE_VERSION_1_1 + 1);
+    INIT_FEATURES();
+    EXPECT_EQ(features.HighestRootSignatureVersion(), D3D_ROOT_SIGNATURE_VERSION_1_1);
+}
+
+// Unavailable test
+TEST_F(FeatureSupportTest, RootSignatureUnavailable)
+{
+    device->m_RootSignatureAvailable = false;
+    device->m_RootSignatureHighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1;
+    INIT_FEATURES();
+    EXPECT_EQ(features.HighestRootSignatureVersion(), 0);
+}
+
+// 18: Options2
+// Basic test
+TEST_F(FeatureSupportTest, D3D12Options2Basic)
+{
+    device->m_DepthBoundsTestSupport = true;
+    device->m_ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2;
+    INIT_FEATURES();
+    EXPECT_TRUE(features.DepthBoundsTestSupported());
+    EXPECT_EQ(features.ProgrammableSamplePositionsTier(), D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2);
+}
+
+// Unavailable test
+TEST_F(FeatureSupportTest, D3D12Options2Unavailable)
+{
+    device->m_Options2Available = false;
+    device->m_DepthBoundsTestSupport = true;
+    device->m_ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2;
+    INIT_FEATURES();
+    EXPECT_FALSE(features.DepthBoundsTestSupported());
+    EXPECT_EQ(features.ProgrammableSamplePositionsTier(), D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED);
+}
+
+// 19: Shader Cache
+// Basic test
+TEST_F(FeatureSupportTest, ShaderCacheBasic)
+{
+    D3D12_SHADER_CACHE_SUPPORT_FLAGS outFlags = D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO 
+        | D3D12_SHADER_CACHE_SUPPORT_LIBRARY
+        | D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE
+        | D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE
+        | D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR
+        | D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE;
+    device->m_ShaderCacheSupportFlags = outFlags;
+    
+    INIT_FEATURES();
+    EXPECT_EQ(features.ShaderCacheSupportFlags(), outFlags);
+}
+
+// Unavailable test
+TEST_F(FeatureSupportTest, ShaderCacheUnavailable)
+{
+    device->m_ShaderCacheAvailable = false;
+    D3D12_SHADER_CACHE_SUPPORT_FLAGS outFlags = D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO 
+        | D3D12_SHADER_CACHE_SUPPORT_LIBRARY
+        | D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE
+        | D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE
+        | D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR
+        | D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE;
+    device->m_ShaderCacheSupportFlags = outFlags;
+    
+    INIT_FEATURES();
+    EXPECT_EQ(features.ShaderCacheSupportFlags(), D3D12_SHADER_CACHE_SUPPORT_NONE);
+}
+
+// 20: Command Queue Priority
+// Basic positive test
+TEST_F(FeatureSupportTest, CommandQueuePriorityBasic)
+{
+    device->m_GlobalRealtimeCommandQueueSupport = true;
+    INIT_FEATURES();
+    EXPECT_TRUE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_NORMAL));
+    EXPECT_TRUE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_HIGH));
+    EXPECT_TRUE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME));
+}
+
+// Negative tests
+TEST_F(FeatureSupportTest, CommandQueuePriorityNegative)
+{
+    device->m_GlobalRealtimeCommandQueueSupport = false;
+    INIT_FEATURES();
+    EXPECT_FALSE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE, D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME)); // Global realtime not on
+    EXPECT_FALSE(features.CommandQueuePrioritySupported((D3D12_COMMAND_LIST_TYPE)(D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE+1), D3D12_COMMAND_QUEUE_PRIORITY_NORMAL)); // Unknown command list type
+    EXPECT_FALSE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_COMPUTE, (D3D12_COMMAND_QUEUE_PRIORITY)10)); // Unknown Priority level
+}
+
+// Unavailable test
+TEST_F(FeatureSupportTest, CommandQueuePriorityUnavailable)
+{
+    device->m_CommandQueuePriorityAvailable = false;
+    
+    device->m_GlobalRealtimeCommandQueueSupport = true;
+    INIT_FEATURES();
+    EXPECT_FALSE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_NORMAL));
+    EXPECT_FALSE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_HIGH));
+    EXPECT_FALSE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME));
+}
+
+// 21: Options3
+// Basic Test
+TEST_F(FeatureSupportTest, Options3Basic)
+{
+    device->m_CopyQueueTimestampQueriesSupported = true;
+    device->m_CastingFullyTypedFormatsSupported = true;
+    device->m_GetCachedWriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT | D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE;
+    device->m_ViewInstancingTier = D3D12_VIEW_INSTANCING_TIER_3;
+    device->m_BarycentricsSupported = true;
+
+    INIT_FEATURES();
+
+    EXPECT_TRUE(features.CopyQueueTimestampQueriesSupported());
+    EXPECT_TRUE(features.CastingFullyTypedFormatSupported());
+    EXPECT_EQ(features.WriteBufferImmediateSupportFlags(), D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT | D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE);
+    EXPECT_EQ(features.ViewInstancingTier(), D3D12_VIEW_INSTANCING_TIER_3);
+    EXPECT_TRUE(features.BarycentricsSupported());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options3Unavailable)
+{
+    device->m_Options3Available = false;
+    device->m_CopyQueueTimestampQueriesSupported = true;
+    device->m_CastingFullyTypedFormatsSupported = true;
+    device->m_GetCachedWriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT | D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE;
+    device->m_ViewInstancingTier = D3D12_VIEW_INSTANCING_TIER_3;
+    device->m_BarycentricsSupported = true;
+
+    INIT_FEATURES();
+
+    EXPECT_FALSE(features.CopyQueueTimestampQueriesSupported());
+    EXPECT_FALSE(features.CastingFullyTypedFormatSupported());
+    EXPECT_EQ(features.WriteBufferImmediateSupportFlags(), D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE);
+    EXPECT_EQ(features.ViewInstancingTier(), D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED);
+    EXPECT_FALSE(features.BarycentricsSupported());
+}
+
+// 22: Existing Heaps
+// Basic Test
+TEST_F(FeatureSupportTest, ExistingHeapsBasic)
+{
+    device->m_ExistingHeapCaps = true;
+    INIT_FEATURES();
+    EXPECT_TRUE(features.ExistingHeapsSupported());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, ExistingHeapsUnavailable)
+{
+    device->m_ExistingHeapsAvailable = false;
+    device->m_ExistingHeapCaps = true;
+    INIT_FEATURES();
+    EXPECT_FALSE(features.ExistingHeapsSupported());
+}
+
+// 23: Options4
+// Basic Test
+TEST_F(FeatureSupportTest, Options4Basic)
+{
+    device->m_MSAA64KBAlignedTextureSupported = true;
+    device->m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2; // Duplicate member
+    device->m_Native16BitShaderOpsSupported = true;
+
+    INIT_FEATURES();
+    EXPECT_TRUE(features.MSAA64KBAlignedTextureSupported());
+    EXPECT_EQ(features.SharedResourceCompatibilityTier(), D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2);
+    EXPECT_TRUE(features.Native16BitShaderOpsSupported());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options4Unavailable)
+{
+    device->m_Options4Available = false;
+    device->m_MSAA64KBAlignedTextureSupported = true;
+    device->m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2; // Duplicate member
+    device->m_Native16BitShaderOpsSupported = true;
+
+    INIT_FEATURES();
+    EXPECT_FALSE(features.MSAA64KBAlignedTextureSupported());
+    EXPECT_EQ(features.SharedResourceCompatibilityTier(), D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0);
+    EXPECT_FALSE(features.Native16BitShaderOpsSupported());
+}
+
+// 24: Serialization
+// Basic Test
+TEST_F(FeatureSupportTest, SerializationBasic)
+{
+    device->m_HeapSerializationTier[0] = D3D12_HEAP_SERIALIZATION_TIER_10;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.HeapSerializationTier(), D3D12_HEAP_SERIALIZATION_TIER_10);
+}
+
+// Multinode Test
+TEST_F(FeatureSupportTest, SerializationMultinode)
+{
+    device->SetNodeCount(3);
+    device->m_HeapSerializationTier = 
+    {
+        D3D12_HEAP_SERIALIZATION_TIER_10,
+        D3D12_HEAP_SERIALIZATION_TIER_0,
+        D3D12_HEAP_SERIALIZATION_TIER_10
+    };
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.HeapSerializationTier(), D3D12_HEAP_SERIALIZATION_TIER_10);
+    EXPECT_EQ(features.HeapSerializationTier(1), D3D12_HEAP_SERIALIZATION_TIER_0);
+    EXPECT_EQ(features.HeapSerializationTier(2), D3D12_HEAP_SERIALIZATION_TIER_10);
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, SerializationUnavailable)
+{
+    device->m_SerializationAvailable = false;
+    device->SetNodeCount(3);
+    device->m_HeapSerializationTier = 
+    {
+        D3D12_HEAP_SERIALIZATION_TIER_10,
+        D3D12_HEAP_SERIALIZATION_TIER_0,
+        D3D12_HEAP_SERIALIZATION_TIER_10
+    };
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.HeapSerializationTier(), D3D12_HEAP_SERIALIZATION_TIER_0);
+    EXPECT_EQ(features.HeapSerializationTier(1), D3D12_HEAP_SERIALIZATION_TIER_0);
+    EXPECT_EQ(features.HeapSerializationTier(2), D3D12_HEAP_SERIALIZATION_TIER_0);
+}
+
+// 25: Cross Node
+// Basic Test
+TEST_F(FeatureSupportTest, CrossNodeBasic)
+{
+    device->m_CrossNodeSharingTier = D3D12_CROSS_NODE_SHARING_TIER_3; // Duplicated Cap
+    device->m_AtomicShaderInstructions = true;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.CrossNodeSharingTier(), D3D12_CROSS_NODE_SHARING_TIER_3);
+    EXPECT_TRUE(features.CrossNodeAtomicShaderInstructions());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, CrossNodeUnavailable)
+{
+    device->m_CrossNodeAvailable = false;
+    device->m_CrossNodeSharingTier = D3D12_CROSS_NODE_SHARING_TIER_3; // Duplicated Cap
+    device->m_AtomicShaderInstructions = true;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.CrossNodeSharingTier(), D3D12_CROSS_NODE_SHARING_TIER_3); // It is still correctly initialized by Options1
+    EXPECT_FALSE(features.CrossNodeAtomicShaderInstructions());
+}
+
+// 27: Options5
+// Basic Test
+TEST_F(FeatureSupportTest, Options5Basic)
+{
+    device->m_RaytracingTier = D3D12_RAYTRACING_TIER_1_1;
+    device->m_RenderPassesTier = D3D12_RENDER_PASS_TIER_2;
+    device->m_SRVOnlyTiledResourceTier3 = true;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.RaytracingTier(), D3D12_RAYTRACING_TIER_1_1);
+    EXPECT_EQ(features.RenderPassesTier(), D3D12_RENDER_PASS_TIER_2);
+    EXPECT_TRUE(features.SRVOnlyTiledResourceTier3());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options5Unavailable)
+{
+    device->m_Options5Available = false;
+    device->m_RaytracingTier = D3D12_RAYTRACING_TIER_1_1;
+    device->m_RenderPassesTier = D3D12_RENDER_PASS_TIER_2;
+    device->m_SRVOnlyTiledResourceTier3 = true;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.RaytracingTier(), D3D12_RAYTRACING_TIER_NOT_SUPPORTED);
+    EXPECT_EQ(features.RenderPassesTier(), D3D12_RENDER_PASS_TIER_0);
+    EXPECT_FALSE(features.SRVOnlyTiledResourceTier3());
+}
+
+// 28: Displayable
+// Basic Test
+TEST_F(FeatureSupportTest, DisplayableBasic)
+{
+    device->m_DisplayableTexture = true;
+    device->m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2;
+
+    INIT_FEATURES();
+
+    EXPECT_TRUE(features.DisplayableTexture());
+    EXPECT_EQ(features.SharedResourceCompatibilityTier(), D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2);
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, DisplayableUnavailable)
+{
+    device->m_DisplayableAvailable = false;
+    device->m_DisplayableTexture = true;
+    device->m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2;
+
+    INIT_FEATURES();
+
+    EXPECT_FALSE(features.DisplayableTexture());
+    EXPECT_EQ(features.SharedResourceCompatibilityTier(), D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2); // Still initialized by Options4
+}
+
+// 30: D3D12 Options6
+// Basic Test
+TEST_F(FeatureSupportTest, Options6Basic)
+{
+    device->m_AdditionalShadingRatesSupported = true;
+    device->m_BackgroundProcessingSupported = true;
+    device->m_PerPrimitiveShadingRateSupportedWithViewportIndexing = true;
+    device->m_ShadingRateImageTileSize = 10;
+    device->m_VariableShadingRateTier = D3D12_VARIABLE_SHADING_RATE_TIER_2;
+
+    INIT_FEATURES();
+
+    EXPECT_TRUE(features.AdditionalShadingRatesSupported());
+    EXPECT_TRUE(features.BackgroundProcessingSupported());
+    EXPECT_TRUE(features.PerPrimitiveShadingRateSupportedWithViewportIndexing());
+    EXPECT_EQ(features.ShadingRateImageTileSize(), 10);
+    EXPECT_EQ(features.VariableShadingRateTier(), D3D12_VARIABLE_SHADING_RATE_TIER_2);
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options6Unavailable)
+{
+    device->m_Options6Available = false;
+    device->m_AdditionalShadingRatesSupported = true;
+    device->m_BackgroundProcessingSupported = true;
+    device->m_PerPrimitiveShadingRateSupportedWithViewportIndexing = true;
+    device->m_ShadingRateImageTileSize = 10;
+    device->m_VariableShadingRateTier = D3D12_VARIABLE_SHADING_RATE_TIER_2;
+
+    INIT_FEATURES();
+
+    EXPECT_FALSE(features.AdditionalShadingRatesSupported());
+    EXPECT_FALSE(features.BackgroundProcessingSupported());
+    EXPECT_FALSE(features.PerPrimitiveShadingRateSupportedWithViewportIndexing());
+    EXPECT_EQ(features.ShadingRateImageTileSize(), 0);
+    EXPECT_EQ(features.VariableShadingRateTier(), D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED);
+}
+
+// 31: Query Meta Command
+// Only performs input and output consistency checks; not reflecting results from real device
+// Basic Test
+TEST_F(FeatureSupportTest, QueryMetaCommandBasic)
+{
+    UINT MockOutput[2] = {2, 8};
+    UINT MockOutputSize = sizeof(MockOutput);
+    device->m_pQueryOutputData = MockOutput;
+    device->m_QueryOutputDataSizeInBytes = MockOutputSize;
+
+    UINT MockInput[3] = {3, 6, 42};
+    UINT MockInputSize = sizeof(MockInput);
+    GUID MockCommandID = {1, 5, 9, {12, 17, 23, 38}}; // Not a real CommandID
+    UINT MockNodeMask = 0x12;
+
+    D3D12_FEATURE_DATA_QUERY_META_COMMAND QueryData;
+    QueryData.CommandId = MockCommandID;
+    QueryData.NodeMask = MockNodeMask;
+    QueryData.QueryInputDataSizeInBytes = MockInputSize;
+    QueryData.pQueryInputData = MockInput;
+    QueryData.QueryOutputDataSizeInBytes = MockOutputSize;
+    QueryData.pQueryOutputData = MockOutput;
+
+    INIT_FEATURES();
+
+    HRESULT result = features.QueryMetaCommand(QueryData);
+    EXPECT_EQ(result, S_OK);
+    EXPECT_EQ(device->m_CommandID, MockCommandID);
+    EXPECT_EQ(device->m_NodeMask, MockNodeMask);
+    EXPECT_EQ(device->m_QueryInputDataSizeInBytes, MockInputSize);
+    EXPECT_EQ(device->m_pQueryInputData, MockInput);
+    EXPECT_EQ(QueryData.QueryOutputDataSizeInBytes, MockOutputSize);
+    EXPECT_EQ(QueryData.pQueryOutputData, MockOutput);
+}
+
+// 32: Options7
+// Basic Test
+TEST_F(FeatureSupportTest, Options7Basic)
+{
+    device->m_MeshShaderTier = D3D12_MESH_SHADER_TIER_1;
+    device->m_SamplerFeedbackTier = D3D12_SAMPLER_FEEDBACK_TIER_1_0;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.MeshShaderTier(), D3D12_MESH_SHADER_TIER_1);
+    EXPECT_EQ(features.SamplerFeedbackTier(), D3D12_SAMPLER_FEEDBACK_TIER_1_0);
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options7Unavailable)
+{
+    device->m_Options7Available = false;
+    device->m_MeshShaderTier = D3D12_MESH_SHADER_TIER_1;
+    device->m_SamplerFeedbackTier = D3D12_SAMPLER_FEEDBACK_TIER_1_0;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.MeshShaderTier(), D3D12_MESH_SHADER_TIER_NOT_SUPPORTED);
+    EXPECT_EQ(features.SamplerFeedbackTier(), D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED);
+}
+
+// 33: Protected Resource Session Type Count
+// Basic Test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionTypeCountBasic)
+{
+    device->m_ProtectedResourceSessionTypeCount[0] = 5;
+    device->m_ProtectedResourceSessionTypes[0].resize(5); // Must set the session types to a correct number
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(0), 5);
+}
+
+// Multinode Test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionTypeCountMultinode)
+{
+    device->SetNodeCount(3);
+    device->m_ProtectedResourceSessionTypeCount = {3, 14, 21};
+    device->m_ProtectedResourceSessionTypes[0].resize(3);
+    device->m_ProtectedResourceSessionTypes[1].resize(14);
+    device->m_ProtectedResourceSessionTypes[2].resize(21);
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(0), 3);
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(1), 14);
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(2), 21);
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionTypeCountUnavailable)
+{
+    device->m_ProtectedResourceSessionTypeCountAvailable = false;
+    device->SetNodeCount(3);
+    device->m_ProtectedResourceSessionTypeCount = {3, 14, 21};
+    device->m_ProtectedResourceSessionTypes[0].resize(3);
+    device->m_ProtectedResourceSessionTypes[1].resize(14);
+    device->m_ProtectedResourceSessionTypes[2].resize(21);
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(0), 0);
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(1), 0);
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(2), 0);
+}
+
+// 34: Protected Resource Session Types
+// Note: Protected Resource Seesion Type Count must be correctly set for this feature
+// Basic Test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionTypesBasic)
+{
+    device->m_ProtectedResourceSessionTypeCount[0] = 2;
+    device->m_ProtectedResourceSessionTypes[0] = {{1, 1, 2, {3, 5, 8, 13}}, {1, 4, 9, {16, 25, 36, 49}}}; // Some random GUID test data
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionTypes(), device->m_ProtectedResourceSessionTypes[0]);
+}
+
+// Multinode Test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionTypesMultinode)
+{
+    device->SetNodeCount(2);
+    device->m_ProtectedResourceSessionTypeCount = {2, 1};
+    device->m_ProtectedResourceSessionTypes[0] = {{1, 1, 2, {3, 5, 8, 13}}, {1, 4, 9, {16, 25, 36, 49}}}; // Some random GUID test data
+    device->m_ProtectedResourceSessionTypes[1] = {{5, 7, 9, {11, 13, 15, 17}}};
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionTypes(0), device->m_ProtectedResourceSessionTypes[0]);
+    EXPECT_EQ(features.ProtectedResourceSessionTypes(1), device->m_ProtectedResourceSessionTypes[1]);
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, ProtectedResourceSessionTypesUnavailable)
+{
+    device->m_ProtectedResourceSessionTypesAvailable = false;
+    device->m_ProtectedResourceSessionTypeCount[0] = 2;
+    device->m_ProtectedResourceSessionTypes[0] = {{1, 1, 2, {3, 5, 8, 13}}, {1, 4, 9, {16, 25, 36, 49}}}; // Some random GUID test data
+
+    INIT_FEATURES();
+
+    // If the check fails, the types vector should remain empty
+    EXPECT_EQ(features.ProtectedResourceSessionTypes(0).size(), 0);
+}
+
+// Test where ProtectedResourceSessiontTypeCount is unavailable
+TEST_F(FeatureSupportTest, ProtectedResourceSessionTypesCascadeUnavailable)
+{
+    device->m_ProtectedResourceSessionTypeCountAvailable = false;
+    device->m_ProtectedResourceSessionTypeCount[0] = 2;
+    device->m_ProtectedResourceSessionTypes[0] = {{1, 1, 2, {3, 5, 8, 13}}, {1, 4, 9, {16, 25, 36, 49}}}; // Some random GUID test data
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(0), 0);
+    EXPECT_EQ(features.ProtectedResourceSessionTypes(0).size(), 0);
+}
+
+// 36: Options8
+// Basic Test
+TEST_F(FeatureSupportTest, Options8Basic)
+{
+    device->m_UnalignedBlockTexturesSupported = true;
+    INIT_FEATURES();
+    EXPECT_TRUE(features.UnalignedBlockTexturesSupported());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options8Unavailable)
+{
+    device->m_Options8Available = false;
+    device->m_UnalignedBlockTexturesSupported = true;
+    INIT_FEATURES();
+    EXPECT_FALSE(features.UnalignedBlockTexturesSupported());
+}
+
+// 37: Options9
+// Basic Test
+TEST_F(FeatureSupportTest, Options9Basic)
+{
+    device->m_MeshShaderPipelineStatsSupported = true;
+    device->m_MeshShaderSupportsFullRangeRenderTargetArrayIndex = true;
+    device->m_AtomicInt64OnTypedResourceSupported = true;
+    device->m_AtomicInt64OnGroupSharedSupported = true;
+    device->m_DerivativesInMeshAndAmplificationShadersSupported = true;
+    device->m_WaveMMATier = D3D12_WAVE_MMA_TIER_1_0;
+
+    INIT_FEATURES();
+
+    EXPECT_TRUE(features.MeshShaderPipelineStatsSupported());
+    EXPECT_TRUE(features.MeshShaderSupportsFullRangeRenderTargetArrayIndex());
+    EXPECT_TRUE(features.AtomicInt64OnTypedResourceSupported());
+    EXPECT_TRUE(features.AtomicInt64OnGroupSharedSupported());
+    EXPECT_TRUE(features.DerivativesInMeshAndAmplificationShadersSupported());
+    EXPECT_EQ(features.WaveMMATier(), D3D12_WAVE_MMA_TIER_1_0);
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options9Unavailable)
+{
+    device->m_Options9Available = false;
+    device->m_MeshShaderPipelineStatsSupported = true;
+    device->m_MeshShaderSupportsFullRangeRenderTargetArrayIndex = true;
+    device->m_AtomicInt64OnTypedResourceSupported = true;
+    device->m_AtomicInt64OnGroupSharedSupported = true;
+    device->m_DerivativesInMeshAndAmplificationShadersSupported = true;
+    device->m_WaveMMATier = D3D12_WAVE_MMA_TIER_1_0;
+
+    INIT_FEATURES();
+
+    EXPECT_FALSE(features.MeshShaderPipelineStatsSupported());
+    EXPECT_FALSE(features.MeshShaderSupportsFullRangeRenderTargetArrayIndex());
+    EXPECT_FALSE(features.AtomicInt64OnTypedResourceSupported());
+    EXPECT_FALSE(features.AtomicInt64OnGroupSharedSupported());
+    EXPECT_FALSE(features.DerivativesInMeshAndAmplificationShadersSupported());
+    EXPECT_EQ(features.WaveMMATier(), D3D12_WAVE_MMA_TIER_NOT_SUPPORTED);
+}
+
+// 39: Options10
+// Basic Test
+TEST_F(FeatureSupportTest, Options10Basic)
+{
+    device->m_VariableRateShadingSumCombinerSupported = true;
+    device->m_MeshShaderPerPrimitiveShadingRateSupported = true;
+    
+    INIT_FEATURES();
+
+    EXPECT_TRUE(features.VariableRateShadingSumCombinerSupported());
+    EXPECT_TRUE(features.MeshShaderPerPrimitiveShadingRateSupported());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options10Unavailable)
+{
+    device->m_Options10Available = false;
+    device->m_VariableRateShadingSumCombinerSupported = true;
+    device->m_MeshShaderPerPrimitiveShadingRateSupported = true;
+    
+    INIT_FEATURES();
+
+    EXPECT_FALSE(features.VariableRateShadingSumCombinerSupported());
+    EXPECT_FALSE(features.MeshShaderPerPrimitiveShadingRateSupported());
+}
+
+// 40: Options11
+// Basic Test
+TEST_F(FeatureSupportTest, Options11Basic)
+{
+    device->m_AtomicInt64OnDescriptorHeapResourceSupported = true;
+    INIT_FEATURES();
+    EXPECT_TRUE(features.AtomicInt64OnDescriptorHeapResourceSupported());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options11Unavailable)
+{
+    device->m_Options11Available = false;
+    device->m_AtomicInt64OnDescriptorHeapResourceSupported = true;
+    INIT_FEATURES();
+    EXPECT_FALSE(features.AtomicInt64OnDescriptorHeapResourceSupported());
+}
+
+// 41: Options12
+// Basic Test
+TEST_F(FeatureSupportTest, Options12Basic)
+{
+    device->m_MSPrimitivesPipelineStatisticIncludesCulledPrimitives = D3D12_TRI_STATE_TRUE;
+    device->m_EnhancedBarriersSupported = true;
+    INIT_FEATURES();
+    EXPECT_EQ(features.MSPrimitivesPipelineStatisticIncludesCulledPrimitives(), D3D12_TRI_STATE_TRUE);
+    EXPECT_TRUE(features.EnhancedBarriersSupported());
+}
+
+// Unavailable Test
+TEST_F(FeatureSupportTest, Options12Unavailable)
+{
+        device->m_Options12Available = false;
+        device->m_MSPrimitivesPipelineStatisticIncludesCulledPrimitives = D3D12_TRI_STATE_TRUE;
+        device->m_EnhancedBarriersSupported = true;
+        INIT_FEATURES();
+        EXPECT_EQ(features.MSPrimitivesPipelineStatisticIncludesCulledPrimitives(), D3D12_TRI_STATE_UNKNOWN);
+    EXPECT_FALSE(features.EnhancedBarriersSupported());
+}
+
+// Duplicate Caps Tests
+// This test ensures that caps that are present in more than one features reports correctly
+// when either of them are unavailable on the runtime
+
+// Cross Node Sharing Tier: D3D12Options, CrossNode
+TEST_F(FeatureSupportTest, DuplicateCrossNodeSharingTier)
+{
+    device->m_CrossNodeSharingTier = D3D12_CROSS_NODE_SHARING_TIER_3;
+    device->m_CrossNodeAvailable = false;
+
+    INIT_FEATURES();
+
+    EXPECT_EQ(features.CrossNodeSharingTier(), D3D12_CROSS_NODE_SHARING_TIER_3);
+}
+
+// Shared Resource Compatibility Tier: D3D12Options4, Displayable
+TEST_F(FeatureSupportTest, DuplicateSharedResourceCompatibilityTier)
+{
+    device->m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2;
+    device->m_DisplayableAvailable = false;
+
+    INIT_FEATURES();
+    EXPECT_EQ(features.SharedResourceCompatibilityTier(), D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2);
+}
+
+// Test where both features are unavailable
+TEST_F(FeatureSupportTest, DuplicateSharedResourceCompatibilityTierNegatvie)
+{
+    device->m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2;
+    device->m_DisplayableAvailable = false;
+    device->m_Options4Available = false;
+
+    INIT_FEATURES();
+    EXPECT_EQ(features.SharedResourceCompatibilityTier(), D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0); // Fallback to default value
+}
+
+// MaxGPUVirtualAddressBitsPerResource also has duplicates,
+// but since the two features are always supported, no explicit tests are needed.
+
+// System Test
+// Test if the system works when all features are initialized and queries
+// Skips functions that only does forwarding
+TEST_F(FeatureSupportTest, SystemTest)
+{
+    device->SetNodeCount(2);
+    device->m_DoublePrecisionFloatShaderOps = true;
+    device->m_OutputMergerLogicOp = true;
+    device->m_ShaderMinPrecisionSupport10Bit = D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT;
+    device->m_ShaderMinPrecisionSupport16Bit = D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT;
+    device->m_TiledResourcesTier = D3D12_TILED_RESOURCES_TIER_3;
+    device->m_ResourceBindingTier = D3D12_RESOURCE_BINDING_TIER_3;
+    device->m_PSSpecifiedStencilRefSupported = true;
+    device->m_ConservativeRasterizationTier = D3D12_CONSERVATIVE_RASTERIZATION_TIER_2;
+    device->m_MaxGPUVirtualAddressBitsPerResource = 10;
+    device->m_ResourceHeapTier = D3D12_RESOURCE_HEAP_TIER_2;
+    device->m_TypedUAVLoadAdditionalFormats = true;
+    device->m_ROVsSupported = true;
+    device->m_StandardSwizzle64KBSupported = true;
+    device->m_CrossNodeSharingTier = D3D12_CROSS_NODE_SHARING_TIER_3;
+    device->m_CrossAdapterRowMajorTextureSupported = true;
+    device->m_VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = true;
+
+    device->m_Architecture1Available = true;
+    device->m_TileBasedRenderer = {false, true};
+    device->m_UMA = {true, false};
+    device->m_CacheCoherentUMA = {false, true};
+    device->m_IsolatedMMU = {true, true};
+
+    device->m_FeatureLevel = D3D_FEATURE_LEVEL_12_2;
+
+    device->m_MaxGPUVirtualAddressBitsPerProcess = 16;
+
+    device->m_WaveOpsSupported = true;
+    device->m_WaveLaneCountMin = 2;
+    device->m_WaveLaneCountMax = 4;
+    device->m_TotalLaneCount = 8;
+    device->m_ExpandedComputeResourceStates = true;
+    device->m_Int64ShaderOpsSupported = true;
+
+    device->m_ProtectedResourceSessionSupport =
+    {
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE,
+        D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED,
+    };
+
+    device->m_RootSignatureHighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1;
+
+    device->m_DepthBoundsTestSupport = true;
+    device->m_ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2;
+
+    D3D12_SHADER_CACHE_SUPPORT_FLAGS outFlags = D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO 
+        | D3D12_SHADER_CACHE_SUPPORT_LIBRARY
+        | D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE
+        | D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE
+        | D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR
+        | D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE;
+    device->m_ShaderCacheSupportFlags = outFlags;
+
+    device->m_GlobalRealtimeCommandQueueSupport = true;
+
+    device->m_CopyQueueTimestampQueriesSupported = true;
+    device->m_CastingFullyTypedFormatsSupported = true;
+    device->m_GetCachedWriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT | D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE;
+    device->m_ViewInstancingTier = D3D12_VIEW_INSTANCING_TIER_3;
+    device->m_BarycentricsSupported = true;
+
+    device->m_ExistingHeapCaps = true;
+
+    device->m_MSAA64KBAlignedTextureSupported = true;
+    device->m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2;
+    device->m_Native16BitShaderOpsSupported = true;
+
+    device->m_HeapSerializationTier = 
+    {
+        D3D12_HEAP_SERIALIZATION_TIER_10,
+        D3D12_HEAP_SERIALIZATION_TIER_10,
+    };
+
+    device->m_AtomicShaderInstructions = true;
+
+    device->m_RaytracingTier = D3D12_RAYTRACING_TIER_1_1;
+    device->m_RenderPassesTier = D3D12_RENDER_PASS_TIER_2;
+    device->m_SRVOnlyTiledResourceTier3 = true;
+
+    device->m_DisplayableTexture = true;
+
+    device->m_AdditionalShadingRatesSupported = true;
+    device->m_BackgroundProcessingSupported = true;
+    device->m_PerPrimitiveShadingRateSupportedWithViewportIndexing = true;
+    device->m_ShadingRateImageTileSize = 10;
+    device->m_VariableShadingRateTier = D3D12_VARIABLE_SHADING_RATE_TIER_2;
+
+    device->m_MeshShaderTier = D3D12_MESH_SHADER_TIER_1;
+    device->m_SamplerFeedbackTier = D3D12_SAMPLER_FEEDBACK_TIER_1_0;
+
+    device->m_ProtectedResourceSessionTypeCount = {2, 1};
+    device->m_ProtectedResourceSessionTypes[0].resize(3);
+    device->m_ProtectedResourceSessionTypes[1].resize(14);
+
+    device->m_ProtectedResourceSessionTypes[0] = {{1, 1, 2, {3, 5, 8, 13}}, {1, 4, 9, {16, 25, 36, 49}}}; // Some random GUID test data
+    device->m_ProtectedResourceSessionTypes[1] = {{5, 7, 9, {11, 13, 15, 17}}};
+
+    device->m_UnalignedBlockTexturesSupported = true;
+
+    device->m_MeshShaderPipelineStatsSupported = true;
+    device->m_MeshShaderSupportsFullRangeRenderTargetArrayIndex = true;
+    device->m_AtomicInt64OnTypedResourceSupported = true;
+    device->m_AtomicInt64OnGroupSharedSupported = true;
+    device->m_DerivativesInMeshAndAmplificationShadersSupported = true;
+    device->m_WaveMMATier = D3D12_WAVE_MMA_TIER_1_0;
+
+    device->m_VariableRateShadingSumCombinerSupported = true;
+    device->m_MeshShaderPerPrimitiveShadingRateSupported = true;
+
+    device->m_AtomicInt64OnDescriptorHeapResourceSupported = true;
+
+    device->m_MSPrimitivesPipelineStatisticIncludesCulledPrimitives = D3D12_TRI_STATE_TRUE;
+    device->m_EnhancedBarriersSupported = true;
+
+    INIT_FEATURES();
+
+    EXPECT_TRUE(features.DoublePrecisionFloatShaderOps());
+    EXPECT_TRUE(features.OutputMergerLogicOp());
+    EXPECT_EQ(features.MinPrecisionSupport(), D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT | D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT);
+    EXPECT_EQ(features.TiledResourcesTier(), D3D12_TILED_RESOURCES_TIER_3);
+    EXPECT_EQ(features.ResourceBindingTier(), D3D12_RESOURCE_BINDING_TIER_3);
+    EXPECT_TRUE(features.PSSpecifiedStencilRefSupported());
+    EXPECT_TRUE(features.TypedUAVLoadAdditionalFormats());
+    EXPECT_TRUE(features.ROVsSupported());
+    EXPECT_EQ(features.ConservativeRasterizationTier(), D3D12_CONSERVATIVE_RASTERIZATION_TIER_2);
+    EXPECT_EQ(features.MaxGPUVirtualAddressBitsPerResource(), 10);
+    EXPECT_TRUE(features.StandardSwizzle64KBSupported());
+    EXPECT_EQ(features.CrossNodeSharingTier(), D3D12_CROSS_NODE_SHARING_TIER_3);
+    EXPECT_TRUE(features.CrossAdapterRowMajorTextureSupported());
+    EXPECT_TRUE(features.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation());
+    EXPECT_EQ(features.ResourceHeapTier(), D3D12_RESOURCE_HEAP_TIER_2);
+
+    EXPECT_FALSE(features.TileBasedRenderer(0));
+    EXPECT_TRUE(features.TileBasedRenderer(1));
+    EXPECT_TRUE(features.UMA(0));
+    EXPECT_FALSE(features.UMA(1));
+    EXPECT_FALSE(features.CacheCoherentUMA(0));
+    EXPECT_TRUE(features.CacheCoherentUMA(1));
+    EXPECT_TRUE(features.IsolatedMMU(0));
+    EXPECT_TRUE(features.IsolatedMMU(1));
+
+    EXPECT_EQ(features.MaxSupportedFeatureLevel(), D3D_FEATURE_LEVEL_12_2);
+    
+    EXPECT_EQ(features.MaxGPUVirtualAddressBitsPerProcess(), 16);
+    
+    EXPECT_TRUE(features.WaveOps());
+    EXPECT_EQ(features.WaveLaneCountMin(), 2);
+    EXPECT_EQ(features.WaveLaneCountMax(), 4);
+    EXPECT_EQ(features.TotalLaneCount(), 8);
+    EXPECT_TRUE(features.ExpandedComputeResourceStates());
+    EXPECT_TRUE(features.Int64ShaderOps());
+
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(0), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE);
+    EXPECT_EQ(features.ProtectedResourceSessionSupport(1), D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED);
+
+    EXPECT_EQ(features.HighestRootSignatureVersion(), D3D_ROOT_SIGNATURE_VERSION_1_1);
+
+    EXPECT_TRUE(features.DepthBoundsTestSupported());
+    EXPECT_EQ(features.ProgrammableSamplePositionsTier(), D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2);
+
+    EXPECT_EQ(features.ShaderCacheSupportFlags(), outFlags);
+
+    EXPECT_TRUE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_NORMAL));
+    EXPECT_TRUE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_HIGH));
+    EXPECT_TRUE(features.CommandQueuePrioritySupported(D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME));
+
+    EXPECT_TRUE(features.CopyQueueTimestampQueriesSupported());
+    EXPECT_TRUE(features.CastingFullyTypedFormatSupported());
+    EXPECT_EQ(features.WriteBufferImmediateSupportFlags(), D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT | D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE);
+    EXPECT_EQ(features.ViewInstancingTier(), D3D12_VIEW_INSTANCING_TIER_3);
+    EXPECT_TRUE(features.BarycentricsSupported());
+
+    EXPECT_TRUE(features.ExistingHeapsSupported());
+
+    EXPECT_TRUE(features.MSAA64KBAlignedTextureSupported());
+    EXPECT_EQ(features.SharedResourceCompatibilityTier(), D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2);
+    EXPECT_TRUE(features.Native16BitShaderOpsSupported());
+
+    EXPECT_EQ(features.HeapSerializationTier(), D3D12_HEAP_SERIALIZATION_TIER_10);
+    EXPECT_EQ(features.HeapSerializationTier(1), D3D12_HEAP_SERIALIZATION_TIER_10);
+
+    EXPECT_EQ(features.CrossNodeSharingTier(), D3D12_CROSS_NODE_SHARING_TIER_3);
+    EXPECT_TRUE(features.CrossNodeAtomicShaderInstructions());
+
+    EXPECT_EQ(features.RaytracingTier(), D3D12_RAYTRACING_TIER_1_1);
+    EXPECT_EQ(features.RenderPassesTier(), D3D12_RENDER_PASS_TIER_2);
+    EXPECT_TRUE(features.SRVOnlyTiledResourceTier3());
+
+    EXPECT_TRUE(features.DisplayableTexture());
+
+    EXPECT_TRUE(features.AdditionalShadingRatesSupported());
+    EXPECT_TRUE(features.BackgroundProcessingSupported());
+    EXPECT_TRUE(features.PerPrimitiveShadingRateSupportedWithViewportIndexing());
+    EXPECT_EQ(features.ShadingRateImageTileSize(), 10);
+    EXPECT_EQ(features.VariableShadingRateTier(), D3D12_VARIABLE_SHADING_RATE_TIER_2);
+
+    EXPECT_EQ(features.MeshShaderTier(), D3D12_MESH_SHADER_TIER_1);
+    EXPECT_EQ(features.SamplerFeedbackTier(), D3D12_SAMPLER_FEEDBACK_TIER_1_0);
+
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(0), 2);
+    EXPECT_EQ(features.ProtectedResourceSessionTypeCount(1), 1);
+    EXPECT_EQ(features.ProtectedResourceSessionTypes(0), device->m_ProtectedResourceSessionTypes[0]);
+    EXPECT_EQ(features.ProtectedResourceSessionTypes(1), device->m_ProtectedResourceSessionTypes[1]);
+
+    EXPECT_TRUE(features.UnalignedBlockTexturesSupported());
+
+    EXPECT_TRUE(features.MeshShaderPipelineStatsSupported());
+    EXPECT_TRUE(features.MeshShaderSupportsFullRangeRenderTargetArrayIndex());
+    EXPECT_TRUE(features.AtomicInt64OnTypedResourceSupported());
+    EXPECT_TRUE(features.AtomicInt64OnGroupSharedSupported());
+    EXPECT_TRUE(features.DerivativesInMeshAndAmplificationShadersSupported());
+    EXPECT_EQ(features.WaveMMATier(), D3D12_WAVE_MMA_TIER_1_0);
+
+    EXPECT_TRUE(features.VariableRateShadingSumCombinerSupported());
+    EXPECT_TRUE(features.MeshShaderPerPrimitiveShadingRateSupported());
+
+    EXPECT_TRUE(features.AtomicInt64OnDescriptorHeapResourceSupported());
+
+    EXPECT_EQ(features.MSPrimitivesPipelineStatisticIncludesCulledPrimitives(), D3D12_TRI_STATE_TRUE);
+    EXPECT_TRUE(features.EnhancedBarriersSupported());
+}
\ No newline at end of file