| //=== ParseHLSLRootSignatureTest.cpp - Parse Root Signature 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 "clang/AST/ASTContext.h" |
| #include "clang/AST/Expr.h" |
| #include "clang/Basic/Diagnostic.h" |
| #include "clang/Basic/DiagnosticOptions.h" |
| #include "clang/Basic/FileManager.h" |
| #include "clang/Basic/LangOptions.h" |
| #include "clang/Basic/SourceLocation.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "clang/Basic/TargetInfo.h" |
| #include "clang/Lex/HeaderSearch.h" |
| #include "clang/Lex/HeaderSearchOptions.h" |
| #include "clang/Lex/Lexer.h" |
| #include "clang/Lex/ModuleLoader.h" |
| #include "clang/Lex/Preprocessor.h" |
| #include "clang/Lex/PreprocessorOptions.h" |
| |
| #include "clang/Lex/LexHLSLRootSignature.h" |
| #include "clang/Parse/ParseHLSLRootSignature.h" |
| #include "gtest/gtest.h" |
| |
| using namespace clang; |
| using namespace clang::hlsl; |
| using namespace llvm::hlsl::rootsig; |
| |
| namespace { |
| |
| using llvm::dxbc::RootSignatureVersion; |
| |
| // Diagnostic helper for helper tests |
| class ExpectedDiagConsumer : public DiagnosticConsumer { |
| virtual void anchor() {} |
| |
| void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
| const Diagnostic &Info) override { |
| if (!FirstDiag || !ExpectedDiagID.has_value()) { |
| Satisfied = false; |
| return; |
| } |
| FirstDiag = false; |
| |
| Satisfied = ExpectedDiagID.value() == Info.getID(); |
| } |
| |
| bool FirstDiag = true; |
| bool Satisfied = false; |
| std::optional<unsigned> ExpectedDiagID; |
| |
| public: |
| void setNoDiag() { |
| Satisfied = true; |
| ExpectedDiagID = std::nullopt; |
| } |
| |
| void setExpected(unsigned DiagID) { |
| Satisfied = false; |
| ExpectedDiagID = DiagID; |
| } |
| |
| bool isSatisfied() { return Satisfied; } |
| }; |
| |
| // The test fixture. |
| class ParseHLSLRootSignatureTest : public ::testing::Test { |
| protected: |
| ParseHLSLRootSignatureTest() |
| : FileMgr(FileMgrOpts), Consumer(new ExpectedDiagConsumer()), |
| Diags(DiagnosticIDs::create(), DiagOpts, Consumer), |
| SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions) { |
| // This is an arbitrarily chosen target triple to create the target info. |
| TargetOpts->Triple = "dxil"; |
| Target = TargetInfo::CreateTargetInfo(Diags, *TargetOpts); |
| } |
| |
| std::unique_ptr<Preprocessor> createPP(StringRef Source, |
| TrivialModuleLoader &ModLoader) { |
| std::unique_ptr<llvm::MemoryBuffer> Buf = |
| llvm::MemoryBuffer::getMemBuffer(Source); |
| SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf))); |
| |
| HeaderSearchOptions SearchOpts; |
| HeaderSearch HeaderInfo(SearchOpts, SourceMgr, Diags, LangOpts, |
| Target.get()); |
| auto PP = std::make_unique<Preprocessor>( |
| PPOpts, Diags, LangOpts, SourceMgr, HeaderInfo, ModLoader, |
| /*IILookup =*/nullptr, /*OwnsHeaderSearch =*/false); |
| PP->Initialize(*Target); |
| PP->EnterMainSourceFile(); |
| return PP; |
| } |
| |
| std::unique_ptr<ASTContext> createMinimalASTContext() { |
| IdentifierTable Idents(LangOpts); |
| SelectorTable Selectors; |
| Builtin::Context Builtins; |
| |
| return std::make_unique<ASTContext>(LangOpts, SourceMgr, Idents, Selectors, |
| Builtins, TU_Complete); |
| } |
| |
| StringLiteral *wrapSource(std::unique_ptr<ASTContext> &Ctx, |
| StringRef Source) { |
| SourceLocation Locs[1] = {SourceLocation()}; |
| return StringLiteral::Create(*Ctx, Source, StringLiteralKind::Unevaluated, |
| false, Ctx->VoidTy, Locs); |
| } |
| |
| FileSystemOptions FileMgrOpts; |
| FileManager FileMgr; |
| DiagnosticOptions DiagOpts; |
| ExpectedDiagConsumer *Consumer; |
| DiagnosticsEngine Diags; |
| SourceManager SourceMgr; |
| LangOptions LangOpts; |
| PreprocessorOptions PPOpts; |
| std::shared_ptr<TargetOptions> TargetOpts; |
| IntrusiveRefCntPtr<TargetInfo> Target; |
| }; |
| |
| // Valid Parser Tests |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseEmptyTest) { |
| const llvm::StringLiteral Source = R"cc()cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| ASSERT_EQ((int)Parser.getElements().size(), 0); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { |
| using llvm::dxbc::DescriptorRangeFlags; |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(b0), |
| SRV(space = 3, offset = 32, t42, flags = 0, numDescriptors = 4), |
| visibility = SHADER_VISIBILITY_PIXEL, |
| Sampler(s987, space = +2, offset = DESCRIPTOR_RANGE_OFFSET_APPEND), |
| UAV(u4294967294, numDescriptors = unbounded, |
| flags = Descriptors_Volatile | Data_Volatile |
| | Data_Static_While_Set_At_Execute | Data_Static |
| | Descriptors_Static_Keeping_Buffer_Bounds_Checks |
| ) |
| ), |
| DescriptorTable() |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| // First Descriptor Table with 4 elements |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::CBuffer); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, |
| RegisterType::BReg); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 0u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).NumDescriptors, 1u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 0u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Offset, |
| DescriptorTableOffsetAppend); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| DescriptorRangeFlags::DataStaticWhileSetAtExecute); |
| |
| Elem = Elements[1].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::SRV); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, |
| RegisterType::TReg); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 42u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).NumDescriptors, 4u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 3u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Offset, 32u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| DescriptorRangeFlags::None); |
| |
| Elem = Elements[2].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::Sampler); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, |
| RegisterType::SReg); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 987u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).NumDescriptors, 1u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 2u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Offset, |
| DescriptorTableOffsetAppend); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| DescriptorRangeFlags::None); |
| |
| Elem = Elements[3].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::UAV); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, |
| RegisterType::UReg); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.Number, 4294967294u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).NumDescriptors, |
| NumDescriptorsUnbounded); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 0u); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Offset, |
| DescriptorTableOffsetAppend); |
| auto ValidDescriptorRangeFlags = |
| DescriptorRangeFlags::DescriptorsVolatile | |
| DescriptorRangeFlags::DataVolatile | |
| DescriptorRangeFlags::DataStaticWhileSetAtExecute | |
| DescriptorRangeFlags::DataStatic | |
| DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks; |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| ValidDescriptorRangeFlags); |
| |
| Elem = Elements[4].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, (uint32_t)4); |
| ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::Pixel); |
| |
| // Empty Descriptor Table |
| Elem = Elements[5].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, 0u); |
| ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::All); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) { |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler(s0), |
| StaticSampler(s0, maxAnisotropy = 3, space = 4, |
| visibility = SHADER_VISIBILITY_DOMAIN, |
| minLOD = 4.2f, mipLODBias = 0.23e+3, |
| addressW = TEXTURE_ADDRESS_CLAMP, |
| addressV = TEXTURE_ADDRESS_BORDER, |
| filter = FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT, |
| maxLOD = 9000, addressU = TEXTURE_ADDRESS_MIRROR, |
| comparisonFunc = COMPARISON_NOT_EQUAL, |
| borderColor = STATIC_BORDER_COLOR_OPAQUE_BLACK_UINT |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| ASSERT_EQ(Elements.size(), 2u); |
| |
| // Check default values are as expected |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.Number, 0u); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Filter, |
| llvm::dxbc::SamplerFilter::Anisotropic); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU, |
| llvm::dxbc::TextureAddressMode::Wrap); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV, |
| llvm::dxbc::TextureAddressMode::Wrap); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW, |
| llvm::dxbc::TextureAddressMode::Wrap); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.f); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).MaxAnisotropy, 16u); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc, |
| llvm::dxbc::ComparisonFunc::LessEqual); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).BorderColor, |
| llvm::dxbc::StaticBorderColor::OpaqueWhite); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MinLOD, 0.f); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MaxLOD, 3.402823466e+38f); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Space, 0u); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::All); |
| |
| // Check values can be set as expected |
| Elem = Elements[1].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.Number, 0u); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Filter, |
| llvm::dxbc::SamplerFilter::MaximumMinPointMagLinearMipPoint); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU, |
| llvm::dxbc::TextureAddressMode::Mirror); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV, |
| llvm::dxbc::TextureAddressMode::Border); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW, |
| llvm::dxbc::TextureAddressMode::Clamp); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 230.f); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).MaxAnisotropy, 3u); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc, |
| llvm::dxbc::ComparisonFunc::NotEqual); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).BorderColor, |
| llvm::dxbc::StaticBorderColor::OpaqueBlackUint); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MinLOD, 4.2f); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MaxLOD, 9000.f); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Space, 4u); |
| ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::Domain); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseFloatsTest) { |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler(s0, mipLODBias = 0), |
| StaticSampler(s0, mipLODBias = +1), |
| StaticSampler(s0, mipLODBias = -1), |
| StaticSampler(s0, mipLODBias = 42.), |
| StaticSampler(s0, mipLODBias = +4.2), |
| StaticSampler(s0, mipLODBias = -.42), |
| StaticSampler(s0, mipLODBias = .42e+3), |
| StaticSampler(s0, mipLODBias = 42E-12), |
| StaticSampler(s0, mipLODBias = 42.f), |
| StaticSampler(s0, mipLODBias = 4.2F), |
| StaticSampler(s0, mipLODBias = 42.e+10f), |
| StaticSampler(s0, mipLODBias = -2147483648), |
| StaticSampler(s0, mipLODBias = 2147483648), |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.f); |
| |
| Elem = Elements[1].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 1.f); |
| |
| Elem = Elements[2].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, -1.f); |
| |
| Elem = Elements[3].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 42.f); |
| |
| Elem = Elements[4].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 4.2f); |
| |
| Elem = Elements[5].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, -.42f); |
| |
| Elem = Elements[6].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 420.f); |
| |
| Elem = Elements[7].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.000000000042f); |
| |
| Elem = Elements[8].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 42.f); |
| |
| Elem = Elements[9].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 4.2f); |
| |
| Elem = Elements[10].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 420000000000.f); |
| |
| Elem = Elements[11].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, -2147483648.f); |
| |
| Elem = Elements[12].getElement(); |
| ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); |
| ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 2147483648.f); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) { |
| // This test will checks we can set the valid enum for Sampler descriptor |
| // range flags |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable(Sampler(s0, flags = DESCRIPTORS_VOLATILE)) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::Sampler); |
| auto ValidSamplerFlags = |
| llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile; |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidSamplerFlags); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) { |
| const llvm::StringLiteral Source = R"cc( |
| RootConstants(num32BitConstants = 1, b0), |
| RootConstants(b42, space = 3, num32BitConstants = 4294967295, |
| visibility = SHADER_VISIBILITY_HULL |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| ASSERT_EQ(Elements.size(), 2u); |
| |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootConstants>(Elem)); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Num32BitConstants, 1u); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Reg.Number, 0u); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Space, 0u); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::All); |
| |
| Elem = Elements[1].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootConstants>(Elem)); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Num32BitConstants, 4294967295u); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Reg.Number, 42u); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Space, 3u); |
| ASSERT_EQ(std::get<RootConstants>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::Hull); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) { |
| using llvm::dxbc::RootFlags; |
| const llvm::StringLiteral Source = R"cc( |
| RootFlags( |
| deny_domain_shader_root_access | |
| deny_pixel_shader_root_access | |
| local_root_signature | |
| cbv_srv_uav_heap_directly_indexed | |
| deny_amplification_shader_root_access | |
| deny_geometry_shader_root_access | |
| deny_hull_shader_root_access | |
| deny_mesh_shader_root_access | |
| allow_stream_output | |
| sampler_heap_directly_indexed | |
| allow_input_assembler_input_layout | |
| deny_vertex_shader_root_access |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| ASSERT_EQ(Elements.size(), 1u); |
| |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem)); |
| 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; |
| ASSERT_EQ(std::get<RootFlags>(Elem), ValidRootFlags); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseEmptyRootFlagsTest) { |
| using llvm::dxbc::RootFlags; |
| const llvm::StringLiteral Source = R"cc( |
| RootFlags(), |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| ASSERT_EQ(Elements.size(), 1u); |
| |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem)); |
| ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags::None); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseZeroRootFlagsTest) { |
| using llvm::dxbc::RootFlags; |
| const llvm::StringLiteral Source = R"cc( |
| RootFlags(0), |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| ASSERT_EQ(Elements.size(), 1u); |
| |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem)); |
| ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags::None); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { |
| using llvm::dxbc::RootDescriptorFlags; |
| const llvm::StringLiteral Source = R"cc( |
| CBV(b0), |
| SRV(space = 4, t42, visibility = SHADER_VISIBILITY_GEOMETRY, |
| flags = DATA_VOLATILE | DATA_STATIC | DATA_STATIC_WHILE_SET_AT_EXECUTE |
| ), |
| UAV(visibility = SHADER_VISIBILITY_HULL, u34893247), |
| CBV(b0, flags = 0), |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| ASSERT_EQ(Elements.size(), 4u); |
| |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::CBuffer); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::BReg); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 0u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::All); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, |
| RootDescriptorFlags::DataStaticWhileSetAtExecute); |
| |
| Elem = Elements[1].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::SRV); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::TReg); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 42u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 4u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::Geometry); |
| auto ValidRootDescriptorFlags = |
| RootDescriptorFlags::DataVolatile | |
| RootDescriptorFlags::DataStaticWhileSetAtExecute | |
| RootDescriptorFlags::DataStatic; |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, ValidRootDescriptorFlags); |
| |
| Elem = Elements[2].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::UAV); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::UReg); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 34893247u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::Hull); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, |
| RootDescriptorFlags::DataVolatile); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, |
| RootDescriptorFlags::DataVolatile); |
| |
| Elem = Elements[3].getElement(); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::CBuffer); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::BReg); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 0u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, |
| llvm::dxbc::ShaderVisibility::All); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, RootDescriptorFlags::None); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidTrailingCommaTest) { |
| // This test will checks we can handling trailing commas ',' |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(b0, ), |
| SRV(t42), |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidVersion10Test) { |
| // This test checks that the default values are set correctly |
| // when parsing with root signature version 1.0 |
| const llvm::StringLiteral Source = R"cc( |
| CBV(b0), |
| SRV(t0), |
| UAV(u0), |
| DescriptorTable( |
| CBV(b1), |
| SRV(t1), |
| UAV(u1), |
| Sampler(s1), |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_0, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| auto DefRootDescriptorFlag = llvm::dxbc::RootDescriptorFlags::DataVolatile; |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::CBuffer); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, DefRootDescriptorFlag); |
| |
| Elem = Elements[1].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::SRV); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, DefRootDescriptorFlag); |
| |
| Elem = Elements[2].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::UAV); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, DefRootDescriptorFlag); |
| |
| auto ValidNonSamplerFlags = |
| llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile | |
| llvm::dxbc::DescriptorRangeFlags::DataVolatile; |
| Elem = Elements[3].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::CBuffer); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidNonSamplerFlags); |
| |
| Elem = Elements[4].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::SRV); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidNonSamplerFlags); |
| |
| Elem = Elements[5].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::UAV); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidNonSamplerFlags); |
| |
| Elem = Elements[6].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::Sampler); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, ValidVersion11Test) { |
| // This test checks that the default values are set correctly |
| // when parsing with root signature version 1.1 |
| const llvm::StringLiteral Source = R"cc( |
| CBV(b0), |
| SRV(t0), |
| UAV(u0), |
| DescriptorTable( |
| CBV(b1), |
| SRV(t1), |
| UAV(u1), |
| Sampler(s1), |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test no diagnostics produced |
| Consumer->setNoDiag(); |
| |
| ASSERT_FALSE(Parser.parse()); |
| |
| auto Elements = Parser.getElements(); |
| RootElement Elem = Elements[0].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::CBuffer); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, |
| llvm::dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute); |
| |
| Elem = Elements[1].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::SRV); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, |
| llvm::dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute); |
| |
| Elem = Elements[2].getElement(); |
| ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, ResourceClass::UAV); |
| ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, |
| llvm::dxbc::RootDescriptorFlags::DataVolatile); |
| |
| Elem = Elements[3].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::CBuffer); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| llvm::dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute); |
| |
| Elem = Elements[4].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::SRV); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| llvm::dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute); |
| |
| Elem = Elements[5].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::UAV); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| llvm::dxbc::DescriptorRangeFlags::DataVolatile); |
| |
| Elem = Elements[6].getElement(); |
| ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ResourceClass::Sampler); |
| ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, |
| llvm::dxbc::DescriptorRangeFlags::None); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| // Invalid Parser Tests |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedTokenTest) { |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable() |
| space |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_expected_either); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidParseInvalidTokenTest) { |
| const llvm::StringLiteral Source = R"cc( |
| notAnIdentifier |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced - invalid token |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedEndOfStreamTest) { |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced - expected '(' after DescriptorTable |
| Consumer->setExpected(diag::err_expected_after); |
| |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidMissingDTParameterTest) { |
| // This test will check that the parsing fails due a mandatory |
| // parameter (register) not being specified |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV() |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_missing_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidMissingRDParameterTest) { |
| // This test will check that the parsing fails due a mandatory |
| // parameter (register) not being specified |
| const llvm::StringLiteral Source = R"cc( |
| SRV() |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_missing_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidMissingRCParameterTest) { |
| // This test will check that the parsing fails due a mandatory |
| // parameter (num32BitConstants) not being specified |
| const llvm::StringLiteral Source = R"cc( |
| RootConstants(b0) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_missing_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedMandatoryDTParameterTest) { |
| // This test will check that the parsing fails due the same mandatory |
| // parameter being specified multiple times |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(b32, b84) |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedMandatoryRCParameterTest) { |
| // This test will check that the parsing fails due the same mandatory |
| // parameter being specified multiple times |
| const llvm::StringLiteral Source = R"cc( |
| RootConstants(num32BitConstants = 32, num32BitConstants = 24) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedOptionalDTParameterTest) { |
| // This test will check that the parsing fails due the same optional |
| // parameter being specified multiple times |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(space = 2, space = 0) |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedOptionalRCParameterTest) { |
| // This test will check that the parsing fails due the same optional |
| // parameter being specified multiple times |
| const llvm::StringLiteral Source = R"cc( |
| RootConstants( |
| visibility = Shader_Visibility_All, |
| b0, num32BitConstants = 1, |
| visibility = Shader_Visibility_Pixel |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedNumberTest) { |
| // This test will check that the lexing fails due to an integer overflow |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(b4294967296) |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_number_literal_overflow); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidParseOverflowedNegativeNumberTest) { |
| // This test will check that parsing fails due to a unsigned integer having |
| // too large of a magnitude to be interpreted as its negative |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler(s0, mipLODBias = -4294967295) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_number_literal_overflow); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedFloatTest) { |
| // This test will check that the lexing fails due to a float overflow |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler(s0, mipLODBias = 3.402823467e+38F) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_number_literal_overflow); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidLexNegOverflowedFloatTest) { |
| // This test will check that the lexing fails due to negative float overflow |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler(s0, mipLODBias = -3.402823467e+38F) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_number_literal_overflow); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedDoubleTest) { |
| // This test will check that the lexing fails due to an overflow of double |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler(s0, mipLODBias = 1.e+500) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_number_literal_overflow); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidLexUnderflowFloatTest) { |
| // This test will check that the lexing fails due to double underflow |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler(s0, mipLODBias = 10e-309) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_number_literal_underflow); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidNonZeroFlagsTest) { |
| // This test will check that parsing fails when a non-zero integer literal |
| // is given to flags |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(b0, flags = 3) |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_non_zero_flag); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRootElementMissingCommaTest) { |
| // This test will check that an error is produced when there is a missing |
| // comma between parameters |
| const llvm::StringLiteral Source = R"cc( |
| RootFlags() |
| RootConstants(num32BitConstants = 1, b0) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_expected_either); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorTableMissingCommaTest) { |
| // This test will check that an error is produced when there is a missing |
| // comma between parameters |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(b0) |
| visibility = SHADER_VISIBILITY_ALL |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_expected_either); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRootConstantParamsCommaTest) { |
| // This test will check that an error is produced when there is a missing |
| // comma between parameters |
| const llvm::StringLiteral Source = R"cc( |
| RootConstants( |
| num32BitConstants = 1 |
| b0 |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_expected_either); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRootDescriptorParamsCommaTest) { |
| // This test will check that an error is produced when there is a missing |
| // comma between parameters |
| const llvm::StringLiteral Source = R"cc( |
| CBV( |
| b0 |
| flags = 0 |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_expected_either); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorClauseParamsCommaTest) { |
| // This test will check that an error is produced when there is a missing |
| // comma between parameters |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| UAV( |
| u0 |
| flags = 0 |
| ) |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_expected_either); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidStaticSamplerCommaTest) { |
| // This test will check that an error is produced when there is a missing |
| // comma between parameters |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler( |
| s0 |
| maxLOD = 3 |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_expected_either); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRootDescriptorParamTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| SRV(t0, invalid) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorTableParamTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| visibility = SHADER_VISIBILITY_ALL, |
| invalid |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorTableClauseParamTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV(invalid) |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidStaticSamplerParamTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler( |
| s0, |
| filter = FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT, |
| invalid, |
| comparisonFunc = COMPARISON_EQUAL, |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidVisibilityValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| UAV( |
| u0, |
| visibility = SHADER_VISIBILITY_TYPO |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRegisterValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler( |
| b0 |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidFilterValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler( |
| s0, |
| filter = FILTER_TYPO |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidTextureAddressModeValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler( |
| s0, |
| addressU = TEXTURE_ADDRESS_MODE_TYPO |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidComparisonFuncValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler( |
| s0, |
| comparisonFunc = COMPARISON_FUNC_TYPO |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidStaticBorderColorValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| StaticSampler( |
| s0, |
| borderColor = STATIC_BORDER_COLOR_TYPO |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRootFlagsValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| RootFlags( ROOT_FLAG_TYPO ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidRootDescriptorFlagsValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| CBV( flags = DATA_STATIC | ROOT_DESRIPTOR_FLAG_TYPO ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorRangeFlagsValueTest) { |
| // This test will check that an error is produced when there is a invalid |
| // value of a parameter |
| const llvm::StringLiteral Source = R"cc( |
| DescriptorTable( |
| CBV( |
| flags = DATA_STATIC | DESRIPTOR_RANGE_FLAG_TYPO | DESCRIPTORS_VOLATILE |
| ) |
| ) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_invalid_token); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| TEST_F(ParseHLSLRootSignatureTest, InvalidMultipleRootFlagsTest) { |
| // This test will check that an error is produced when there are multiple |
| // root flags provided |
| const llvm::StringLiteral Source = R"cc( |
| RootFlags(DENY_VERTEX_SHADER_ROOT_ACCESS), |
| RootFlags(DENY_PIXEL_SHADER_ROOT_ACCESS) |
| )cc"; |
| |
| auto Ctx = createMinimalASTContext(); |
| StringLiteral *Signature = wrapSource(Ctx, Source); |
| |
| TrivialModuleLoader ModLoader; |
| auto PP = createPP(Source, ModLoader); |
| |
| hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); |
| |
| // Test correct diagnostic produced |
| Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); |
| ASSERT_TRUE(Parser.parse()); |
| |
| ASSERT_TRUE(Consumer->isSatisfied()); |
| } |
| |
| } // anonymous namespace |
