unittests/Frontend/HLSLRootSignatureDumpTest.cpp - llvm-project/llvm - Git at Google

 //===-------- HLSLRootSignatureDumpTest.cpp - RootSignature dump tests ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/Frontend/HLSL/HLSLRootSignature.h"
 #include "gtest/gtest.h"

 using namespace llvm::hlsl::rootsig;

 namespace {

 TEST(HLSLRootSignatureTest, DescriptorCBVClauseDump) {
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::CBuffer;
   Clause.Reg = {RegisterType::BReg, 0};
   Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_1);

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Clause;
   OS.flush();

   std::string Expected = "CBV(b0, numDescriptors = 1, space = 0, "
                          "offset = DescriptorTableOffsetAppend, "
                          "flags = DataStaticWhileSetAtExecute)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::SRV;
   Clause.Reg = {RegisterType::TReg, 0};
   Clause.NumDescriptors = NumDescriptorsUnbounded;
   Clause.Space = 42;
   Clause.Offset = 3;
   Clause.Flags = llvm::dxbc::DescriptorRangeFlags::None;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Clause;
   OS.flush();

   std::string Expected = "SRV(t0, numDescriptors = unbounded, space = 42, "
                          "offset = 3, flags = None)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DescriptorUAVClauseDump) {
   using llvm::dxbc::DescriptorRangeFlags;
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::UAV;
   Clause.Reg = {RegisterType::UReg, 92374};
   Clause.NumDescriptors = 3298;
   Clause.Space = 932847;
   Clause.Offset = 1;
   auto ValidDescriptorRangeFlags =
       DescriptorRangeFlags::DescriptorsVolatile |
       DescriptorRangeFlags::DataVolatile |
       DescriptorRangeFlags::DataStaticWhileSetAtExecute |
       DescriptorRangeFlags::DataStatic |
       DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks;
   Clause.Flags = ValidDescriptorRangeFlags;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Clause;
   OS.flush();

   std::string Expected =
       "UAV(u92374, numDescriptors = 3298, space = 932847, offset = 1, flags = "
       "DescriptorsVolatile | "
       "DataVolatile | "
       "DataStaticWhileSetAtExecute | "
       "DataStatic | "
       "DescriptorsStaticKeepingBufferBoundsChecks)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::Sampler;
   Clause.Reg = {RegisterType::SReg, 0};
   Clause.NumDescriptors = 2;
   Clause.Space = 42;
   Clause.Offset = DescriptorTableOffsetAppend;
   Clause.Flags = llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Clause;
   OS.flush();

   std::string Expected = "Sampler(s0, numDescriptors = 2, space = 42, offset = "
                          "DescriptorTableOffsetAppend, "
                          "flags = DescriptorsVolatile)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DescriptorCBVV10ClauseDump) {
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::CBuffer;
   Clause.Reg = {RegisterType::BReg, 0};
   Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Clause;
   OS.flush();

   std::string Expected = "CBV(b0, numDescriptors = 1, space = 0, "
                          "offset = DescriptorTableOffsetAppend, "
                          "flags = DescriptorsVolatile | DataVolatile)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DescriptorSamplerV10ClauseDump) {
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::Sampler;
   Clause.Reg = {RegisterType::SReg, 0};
   Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Clause;
   OS.flush();

   std::string Expected = "Sampler(s0, numDescriptors = 1, space = 0, offset = "
                          "DescriptorTableOffsetAppend, "
                          "flags = DescriptorsVolatile)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DescriptorTableDump) {
   DescriptorTable Table;
   Table.NumClauses = 4;
   Table.Visibility = llvm::dxbc::ShaderVisibility::Geometry;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Table;
   OS.flush();

   std::string Expected =
       "DescriptorTable(numClauses = 4, visibility = Geometry)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, RootCBVDump) {
   RootDescriptor Descriptor;
   Descriptor.Type = DescriptorType::CBuffer;
   Descriptor.Reg = {RegisterType::BReg, 0};
   Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_1);

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Descriptor;
   OS.flush();

   std::string Expected = "RootCBV(b0, space = 0, "
                          "visibility = All, "
                          "flags = DataStaticWhileSetAtExecute)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, RootSRV10Dump) {
   RootDescriptor Descriptor;
   Descriptor.Type = DescriptorType::SRV;
   Descriptor.Reg = {RegisterType::TReg, 0};
   Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Descriptor;
   OS.flush();

   std::string Expected = "RootSRV(t0, space = 0, "
                          "visibility = All, "
                          "flags = DataVolatile)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, RootUAVV10Dump) {
   RootDescriptor Descriptor;
   Descriptor.Type = DescriptorType::UAV;
   Descriptor.Reg = {RegisterType::UReg, 0};
   Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Descriptor;
   OS.flush();

   std::string Expected = "RootUAV(u0, space = 0, "
                          "visibility = All, "
                          "flags = DataVolatile)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, RootSRVDump) {
   RootDescriptor Descriptor;
   Descriptor.Type = DescriptorType::SRV;
   Descriptor.Reg = {RegisterType::TReg, 0};
   Descriptor.Space = 42;
   Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
   Descriptor.Flags = llvm::dxbc::RootDescriptorFlags::None;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Descriptor;
   OS.flush();

   std::string Expected =
       "RootSRV(t0, space = 42, visibility = Geometry, flags = None)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, RootUAVDump) {
   using llvm::dxbc::RootDescriptorFlags;
   RootDescriptor Descriptor;
   Descriptor.Type = DescriptorType::UAV;
   Descriptor.Reg = {RegisterType::UReg, 92374};
   Descriptor.Space = 932847;
   Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Hull;
   auto ValidRootDescriptorFlags =
       RootDescriptorFlags::DataVolatile |
       RootDescriptorFlags::DataStaticWhileSetAtExecute |
       RootDescriptorFlags::DataStatic;
   Descriptor.Flags = ValidRootDescriptorFlags;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Descriptor;
   OS.flush();

   std::string Expected =
       "RootUAV(u92374, space = 932847, visibility = Hull, flags = "
       "DataVolatile | "
       "DataStaticWhileSetAtExecute | "
       "DataStatic)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DefaultStaticSamplerDump) {
   StaticSampler Sampler;
   Sampler.Reg = {RegisterType::SReg, 0};

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Sampler;
   OS.flush();

   std::string Expected = "StaticSampler(s0, "
                          "filter = Anisotropic, "
                          "addressU = Wrap, "
                          "addressV = Wrap, "
                          "addressW = Wrap, "
                          "mipLODBias = 0.000000e+00, "
                          "maxAnisotropy = 16, "
                          "comparisonFunc = LessEqual, "
                          "borderColor = OpaqueWhite, "
                          "minLOD = 0.000000e+00, "
                          "maxLOD = 3.402823e+38, "
                          "space = 0, "
                          "visibility = All"
                          ")";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DefinedStaticSamplerDump) {
   StaticSampler Sampler;
   Sampler.Reg = {RegisterType::SReg, 0};

   Sampler.Filter = llvm::dxbc::SamplerFilter::ComparisonMinMagLinearMipPoint;
   Sampler.AddressU = llvm::dxbc::TextureAddressMode::Mirror;
   Sampler.AddressV = llvm::dxbc::TextureAddressMode::Border;
   Sampler.AddressW = llvm::dxbc::TextureAddressMode::Clamp;
   Sampler.MipLODBias = 4.8f;
   Sampler.MaxAnisotropy = 32;
   Sampler.CompFunc = llvm::dxbc::ComparisonFunc::NotEqual;
   Sampler.BorderColor = llvm::dxbc::StaticBorderColor::OpaqueBlack;
   Sampler.MinLOD = 1.0f;
   Sampler.MaxLOD = 32.0f;
   Sampler.Space = 7;
   Sampler.Visibility = llvm::dxbc::ShaderVisibility::Domain;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Sampler;
   OS.flush();

   std::string Expected = "StaticSampler(s0, "
                          "filter = ComparisonMinMagLinearMipPoint, "
                          "addressU = Mirror, "
                          "addressV = Border, "
                          "addressW = Clamp, "
                          "mipLODBias = 4.800000e+00, "
                          "maxAnisotropy = 32, "
                          "comparisonFunc = NotEqual, "
                          "borderColor = OpaqueBlack, "
                          "minLOD = 1.000000e+00, "
                          "maxLOD = 3.200000e+01, "
                          "space = 7, "
                          "visibility = Domain"
                          ")";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, DefaultRootConstantsDump) {
   RootConstants Constants;
   Constants.Num32BitConstants = 1;
   Constants.Reg = {RegisterType::BReg, 3};

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Constants;
   OS.flush();

   std::string Expected = "RootConstants(num32BitConstants = 1, b3, space = 0, "
                          "visibility = All)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
   RootConstants Constants;
   Constants.Num32BitConstants = 983;
   Constants.Reg = {RegisterType::BReg, 34593};
   Constants.Space = 7;
   Constants.Visibility = llvm::dxbc::ShaderVisibility::Pixel;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Constants;
   OS.flush();

   std::string Expected = "RootConstants(num32BitConstants = 983, b34593, "
                          "space = 7, visibility = Pixel)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
   llvm::dxbc::RootFlags Flags = llvm::dxbc::RootFlags::None;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << Flags;
   OS.flush();

   std::string Expected = "RootFlags(None)";
   EXPECT_EQ(Out, Expected);
 }

 TEST(HLSLRootSignatureTest, AllRootFlagsDump) {
   using llvm::dxbc::RootFlags;
   auto ValidRootFlags = RootFlags::AllowInputAssemblerInputLayout |
                         RootFlags::DenyVertexShaderRootAccess |
                         RootFlags::DenyHullShaderRootAccess |
                         RootFlags::DenyDomainShaderRootAccess |
                         RootFlags::DenyGeometryShaderRootAccess |
                         RootFlags::DenyPixelShaderRootAccess |
                         RootFlags::AllowStreamOutput |
                         RootFlags::LocalRootSignature |
                         RootFlags::DenyAmplificationShaderRootAccess |
                         RootFlags::DenyMeshShaderRootAccess |
                         RootFlags::CBVSRVUAVHeapDirectlyIndexed |
                         RootFlags::SamplerHeapDirectlyIndexed;

   std::string Out;
   llvm::raw_string_ostream OS(Out);
   OS << ValidRootFlags;
   OS.flush();

   std::string Expected = "RootFlags("
                          "AllowInputAssemblerInputLayout | "
                          "DenyVertexShaderRootAccess | "
                          "DenyHullShaderRootAccess | "
                          "DenyDomainShaderRootAccess | "
                          "DenyGeometryShaderRootAccess | "
                          "DenyPixelShaderRootAccess | "
                          "AllowStreamOutput | "
                          "LocalRootSignature | "
                          "DenyAmplificationShaderRootAccess | "
                          "DenyMeshShaderRootAccess | "
                          "CBVSRVUAVHeapDirectlyIndexed | "
                          "SamplerHeapDirectlyIndexed)";
   EXPECT_EQ(Out, Expected);
 }

 } // namespace
	//===-------- HLSLRootSignatureDumpTest.cpp - RootSignature dump tests ----===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/Frontend/HLSL/HLSLRootSignature.h"
	#include "gtest/gtest.h"

	using namespace llvm::hlsl::rootsig;

	namespace {

	TEST(HLSLRootSignatureTest, DescriptorCBVClauseDump) {
	DescriptorTableClause Clause;
	Clause.Type = ClauseType::CBuffer;
	Clause.Reg = {RegisterType::BReg, 0};
	Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_1);

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Clause;
	OS.flush();

	std::string Expected = "CBV(b0, numDescriptors = 1, space = 0, "
	"offset = DescriptorTableOffsetAppend, "
	"flags = DataStaticWhileSetAtExecute)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
	DescriptorTableClause Clause;
	Clause.Type = ClauseType::SRV;
	Clause.Reg = {RegisterType::TReg, 0};
	Clause.NumDescriptors = NumDescriptorsUnbounded;
	Clause.Space = 42;
	Clause.Offset = 3;
	Clause.Flags = llvm::dxbc::DescriptorRangeFlags::None;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Clause;
	OS.flush();

	std::string Expected = "SRV(t0, numDescriptors = unbounded, space = 42, "
	"offset = 3, flags = None)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DescriptorUAVClauseDump) {
	using llvm::dxbc::DescriptorRangeFlags;
	DescriptorTableClause Clause;
	Clause.Type = ClauseType::UAV;
	Clause.Reg = {RegisterType::UReg, 92374};
	Clause.NumDescriptors = 3298;
	Clause.Space = 932847;
	Clause.Offset = 1;
	auto ValidDescriptorRangeFlags =
	DescriptorRangeFlags::DescriptorsVolatile \|
	DescriptorRangeFlags::DataVolatile \|
	DescriptorRangeFlags::DataStaticWhileSetAtExecute \|
	DescriptorRangeFlags::DataStatic \|
	DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks;
	Clause.Flags = ValidDescriptorRangeFlags;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Clause;
	OS.flush();

	std::string Expected =
	"UAV(u92374, numDescriptors = 3298, space = 932847, offset = 1, flags = "
	"DescriptorsVolatile \| "
	"DataVolatile \| "
	"DataStaticWhileSetAtExecute \| "
	"DataStatic \| "
	"DescriptorsStaticKeepingBufferBoundsChecks)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
	DescriptorTableClause Clause;
	Clause.Type = ClauseType::Sampler;
	Clause.Reg = {RegisterType::SReg, 0};
	Clause.NumDescriptors = 2;
	Clause.Space = 42;
	Clause.Offset = DescriptorTableOffsetAppend;
	Clause.Flags = llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Clause;
	OS.flush();

	std::string Expected = "Sampler(s0, numDescriptors = 2, space = 42, offset = "
	"DescriptorTableOffsetAppend, "
	"flags = DescriptorsVolatile)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DescriptorCBVV10ClauseDump) {
	DescriptorTableClause Clause;
	Clause.Type = ClauseType::CBuffer;
	Clause.Reg = {RegisterType::BReg, 0};
	Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Clause;
	OS.flush();

	std::string Expected = "CBV(b0, numDescriptors = 1, space = 0, "
	"offset = DescriptorTableOffsetAppend, "
	"flags = DescriptorsVolatile \| DataVolatile)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DescriptorSamplerV10ClauseDump) {
	DescriptorTableClause Clause;
	Clause.Type = ClauseType::Sampler;
	Clause.Reg = {RegisterType::SReg, 0};
	Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Clause;
	OS.flush();

	std::string Expected = "Sampler(s0, numDescriptors = 1, space = 0, offset = "
	"DescriptorTableOffsetAppend, "
	"flags = DescriptorsVolatile)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DescriptorTableDump) {
	DescriptorTable Table;
	Table.NumClauses = 4;
	Table.Visibility = llvm::dxbc::ShaderVisibility::Geometry;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Table;
	OS.flush();

	std::string Expected =
	"DescriptorTable(numClauses = 4, visibility = Geometry)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, RootCBVDump) {
	RootDescriptor Descriptor;
	Descriptor.Type = DescriptorType::CBuffer;
	Descriptor.Reg = {RegisterType::BReg, 0};
	Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_1);

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Descriptor;
	OS.flush();

	std::string Expected = "RootCBV(b0, space = 0, "
	"visibility = All, "
	"flags = DataStaticWhileSetAtExecute)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, RootSRV10Dump) {
	RootDescriptor Descriptor;
	Descriptor.Type = DescriptorType::SRV;
	Descriptor.Reg = {RegisterType::TReg, 0};
	Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Descriptor;
	OS.flush();

	std::string Expected = "RootSRV(t0, space = 0, "
	"visibility = All, "
	"flags = DataVolatile)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, RootUAVV10Dump) {
	RootDescriptor Descriptor;
	Descriptor.Type = DescriptorType::UAV;
	Descriptor.Reg = {RegisterType::UReg, 0};
	Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Descriptor;
	OS.flush();

	std::string Expected = "RootUAV(u0, space = 0, "
	"visibility = All, "
	"flags = DataVolatile)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, RootSRVDump) {
	RootDescriptor Descriptor;
	Descriptor.Type = DescriptorType::SRV;
	Descriptor.Reg = {RegisterType::TReg, 0};
	Descriptor.Space = 42;
	Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
	Descriptor.Flags = llvm::dxbc::RootDescriptorFlags::None;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Descriptor;
	OS.flush();

	std::string Expected =
	"RootSRV(t0, space = 42, visibility = Geometry, flags = None)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, RootUAVDump) {
	using llvm::dxbc::RootDescriptorFlags;
	RootDescriptor Descriptor;
	Descriptor.Type = DescriptorType::UAV;
	Descriptor.Reg = {RegisterType::UReg, 92374};
	Descriptor.Space = 932847;
	Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Hull;
	auto ValidRootDescriptorFlags =
	RootDescriptorFlags::DataVolatile \|
	RootDescriptorFlags::DataStaticWhileSetAtExecute \|
	RootDescriptorFlags::DataStatic;
	Descriptor.Flags = ValidRootDescriptorFlags;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Descriptor;
	OS.flush();

	std::string Expected =
	"RootUAV(u92374, space = 932847, visibility = Hull, flags = "
	"DataVolatile \| "
	"DataStaticWhileSetAtExecute \| "
	"DataStatic)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DefaultStaticSamplerDump) {
	StaticSampler Sampler;
	Sampler.Reg = {RegisterType::SReg, 0};

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Sampler;
	OS.flush();

	std::string Expected = "StaticSampler(s0, "
	"filter = Anisotropic, "
	"addressU = Wrap, "
	"addressV = Wrap, "
	"addressW = Wrap, "
	"mipLODBias = 0.000000e+00, "
	"maxAnisotropy = 16, "
	"comparisonFunc = LessEqual, "
	"borderColor = OpaqueWhite, "
	"minLOD = 0.000000e+00, "
	"maxLOD = 3.402823e+38, "
	"space = 0, "
	"visibility = All"
	")";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DefinedStaticSamplerDump) {
	StaticSampler Sampler;
	Sampler.Reg = {RegisterType::SReg, 0};

	Sampler.Filter = llvm::dxbc::SamplerFilter::ComparisonMinMagLinearMipPoint;
	Sampler.AddressU = llvm::dxbc::TextureAddressMode::Mirror;
	Sampler.AddressV = llvm::dxbc::TextureAddressMode::Border;
	Sampler.AddressW = llvm::dxbc::TextureAddressMode::Clamp;
	Sampler.MipLODBias = 4.8f;
	Sampler.MaxAnisotropy = 32;
	Sampler.CompFunc = llvm::dxbc::ComparisonFunc::NotEqual;
	Sampler.BorderColor = llvm::dxbc::StaticBorderColor::OpaqueBlack;
	Sampler.MinLOD = 1.0f;
	Sampler.MaxLOD = 32.0f;
	Sampler.Space = 7;
	Sampler.Visibility = llvm::dxbc::ShaderVisibility::Domain;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Sampler;
	OS.flush();

	std::string Expected = "StaticSampler(s0, "
	"filter = ComparisonMinMagLinearMipPoint, "
	"addressU = Mirror, "
	"addressV = Border, "
	"addressW = Clamp, "
	"mipLODBias = 4.800000e+00, "
	"maxAnisotropy = 32, "
	"comparisonFunc = NotEqual, "
	"borderColor = OpaqueBlack, "
	"minLOD = 1.000000e+00, "
	"maxLOD = 3.200000e+01, "
	"space = 7, "
	"visibility = Domain"
	")";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, DefaultRootConstantsDump) {
	RootConstants Constants;
	Constants.Num32BitConstants = 1;
	Constants.Reg = {RegisterType::BReg, 3};

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Constants;
	OS.flush();

	std::string Expected = "RootConstants(num32BitConstants = 1, b3, space = 0, "
	"visibility = All)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
	RootConstants Constants;
	Constants.Num32BitConstants = 983;
	Constants.Reg = {RegisterType::BReg, 34593};
	Constants.Space = 7;
	Constants.Visibility = llvm::dxbc::ShaderVisibility::Pixel;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Constants;
	OS.flush();

	std::string Expected = "RootConstants(num32BitConstants = 983, b34593, "
	"space = 7, visibility = Pixel)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
	llvm::dxbc::RootFlags Flags = llvm::dxbc::RootFlags::None;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << Flags;
	OS.flush();

	std::string Expected = "RootFlags(None)";
	EXPECT_EQ(Out, Expected);
	}

	TEST(HLSLRootSignatureTest, AllRootFlagsDump) {
	using llvm::dxbc::RootFlags;
	auto ValidRootFlags = RootFlags::AllowInputAssemblerInputLayout \|
	RootFlags::DenyVertexShaderRootAccess \|
	RootFlags::DenyHullShaderRootAccess \|
	RootFlags::DenyDomainShaderRootAccess \|
	RootFlags::DenyGeometryShaderRootAccess \|
	RootFlags::DenyPixelShaderRootAccess \|
	RootFlags::AllowStreamOutput \|
	RootFlags::LocalRootSignature \|
	RootFlags::DenyAmplificationShaderRootAccess \|
	RootFlags::DenyMeshShaderRootAccess \|
	RootFlags::CBVSRVUAVHeapDirectlyIndexed \|
	RootFlags::SamplerHeapDirectlyIndexed;

	std::string Out;
	llvm::raw_string_ostream OS(Out);
	OS << ValidRootFlags;
	OS.flush();

	std::string Expected = "RootFlags("
	"AllowInputAssemblerInputLayout \| "
	"DenyVertexShaderRootAccess \| "
	"DenyHullShaderRootAccess \| "
	"DenyDomainShaderRootAccess \| "
	"DenyGeometryShaderRootAccess \| "
	"DenyPixelShaderRootAccess \| "
	"AllowStreamOutput \| "
	"LocalRootSignature \| "
	"DenyAmplificationShaderRootAccess \| "
	"DenyMeshShaderRootAccess \| "
	"CBVSRVUAVHeapDirectlyIndexed \| "
	"SamplerHeapDirectlyIndexed)";
	EXPECT_EQ(Out, Expected);
	}

	} // namespace