From: Dejan Mircevski Date: Tue, 10 May 2016 03:15:46 +0000 (-0400) Subject: Add tests for MaxByteOffset. X-Git-Tag: upstream/2018.6~1245 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=4376856b1ac539c571180271ce9596ad970e5817;p=platform%2Fupstream%2FSPIRV-Tools.git Add tests for MaxByteOffset. --- diff --git a/test/OperandCapabilities.cpp b/test/OperandCapabilities.cpp index aa38259..ecbf7ac 100644 --- a/test/OperandCapabilities.cpp +++ b/test/OperandCapabilities.cpp @@ -465,12 +465,11 @@ INSTANTIATE_TEST_CASE_P( SPV_CAPABILITY_AS_MASK(SpvCapabilityShader)}))); INSTANTIATE_TEST_CASE_P( - DecorationSpecIdV11, EnumCapabilityTest, + DecorationV11, EnumCapabilityTest, Combine(Values(SPV_ENV_UNIVERSAL_1_1), - Values(EnumCapabilityCase{ - SPV_OPERAND_TYPE_DECORATION, uint32_t(SpvDecorationSpecId), - (SPV_CAPABILITY_AS_MASK(SpvCapabilityShader) | - SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel))}))); + ValuesIn(std::vector{ + CASE2(DECORATION, DecorationSpecId, Shader, Kernel), + CASE1(DECORATION, DecorationMaxByteOffset, Addresses)})), ); // See SPIR-V Section 3.21 BuiltIn INSTANTIATE_TEST_CASE_P( diff --git a/test/TestFixture.h b/test/TestFixture.h index e580905..4020381 100644 --- a/test/TestFixture.h +++ b/test/TestFixture.h @@ -97,17 +97,13 @@ class TextToBinaryTestBase : public T { } // Encodes SPIR-V text into binary and then decodes the binary using - // default options. Returns the decoded text. - std::string EncodeAndDecodeSuccessfully(const std::string& txt) { - return EncodeAndDecodeSuccessfully(txt, SPV_BINARY_TO_TEXT_OPTION_NONE); - } - - // Encodes SPIR-V text into binary and then decodes the binary using // given options. Returns the decoded text. - std::string EncodeAndDecodeSuccessfully(const std::string& txt, - uint32_t disassemble_options) { + std::string EncodeAndDecodeSuccessfully( + const std::string& txt, + uint32_t disassemble_options = SPV_BINARY_TO_TEXT_OPTION_NONE, + spv_target_env env = SPV_ENV_UNIVERSAL_1_0) { DestroyBinary(); - ScopedContext context; + ScopedContext context(env); spv_result_t error = spvTextToBinary(context.context, txt.c_str(), txt.size(), &binary, &diagnostic); if (error) { diff --git a/test/TextToBinary.Annotation.cpp b/test/TextToBinary.Annotation.cpp index f6ca6a3..3f4d550 100644 --- a/test/TextToBinary.Annotation.cpp +++ b/test/TextToBinary.Annotation.cpp @@ -30,83 +30,98 @@ #include "UnitSPIRV.h" #include +#include -#include "gmock/gmock.h" #include "TestFixture.h" +#include "gmock/gmock.h" namespace { +using ::testing::Combine; +using ::testing::Eq; +using ::testing::Values; +using ::testing::ValuesIn; using spvtest::EnumCase; using spvtest::MakeInstruction; using spvtest::MakeVector; using spvtest::TextToBinaryTest; -using ::testing::Eq; +using std::get; +using std::tuple; // Test OpDecorate using OpDecorateSimpleTest = spvtest::TextToBinaryTestBase< - ::testing::TestWithParam>>; + ::testing::TestWithParam>>>; TEST_P(OpDecorateSimpleTest, AnySimpleDecoration) { // This string should assemble, but should not validate. std::stringstream input; - input << "OpDecorate %1 " << GetParam().name(); - for (auto operand : GetParam().operands()) input << " " << operand; + input << "OpDecorate %1 " << get<1>(GetParam()).name(); + for (auto operand : get<1>(GetParam()).operands()) input << " " << operand; input << std::endl; - EXPECT_THAT( - CompiledInstructions(input.str()), - Eq(MakeInstruction(SpvOpDecorate, {1, uint32_t(GetParam().value())}, - GetParam().operands()))); + EXPECT_THAT(CompiledInstructions(input.str(), get<0>(GetParam())), + Eq(MakeInstruction(SpvOpDecorate, + {1, uint32_t(get<1>(GetParam()).value())}, + get<1>(GetParam()).operands()))); // Also check disassembly. - EXPECT_THAT(EncodeAndDecodeSuccessfully(input.str()), Eq(input.str())); + EXPECT_THAT( + EncodeAndDecodeSuccessfully(input.str(), SPV_BINARY_TO_TEXT_OPTION_NONE, + get<0>(GetParam())), + Eq(input.str())); } #define CASE(NAME) SpvDecoration##NAME, #NAME INSTANTIATE_TEST_CASE_P( TextToBinaryDecorateSimple, OpDecorateSimpleTest, - ::testing::ValuesIn(std::vector>{ - // The operand literal values are arbitrarily chosen, - // but there are the right number of them. - {CASE(RelaxedPrecision), {}}, - {CASE(SpecId), {100}}, - {CASE(Block), {}}, - {CASE(BufferBlock), {}}, - {CASE(RowMajor), {}}, - {CASE(ColMajor), {}}, - {CASE(ArrayStride), {4}}, - {CASE(MatrixStride), {16}}, - {CASE(GLSLShared), {}}, - {CASE(GLSLPacked), {}}, - {CASE(CPacked), {}}, - // Placeholder line for enum value 12 - {CASE(NoPerspective), {}}, - {CASE(Flat), {}}, - {CASE(Patch), {}}, - {CASE(Centroid), {}}, - {CASE(Sample), {}}, - {CASE(Invariant), {}}, - {CASE(Restrict), {}}, - {CASE(Aliased), {}}, - {CASE(Volatile), {}}, - {CASE(Constant), {}}, - {CASE(Coherent), {}}, - {CASE(NonWritable), {}}, - {CASE(NonReadable), {}}, - {CASE(Uniform), {}}, - {CASE(SaturatedConversion), {}}, - {CASE(Stream), {2}}, - {CASE(Location), {6}}, - {CASE(Component), {3}}, - {CASE(Index), {14}}, - {CASE(Binding), {19}}, - {CASE(DescriptorSet), {7}}, - {CASE(Offset), {12}}, - {CASE(XfbBuffer), {1}}, - {CASE(XfbStride), {8}}, - {CASE(NoContraction), {}}, - {CASE(InputAttachmentIndex), {102}}, - {CASE(Alignment), {16}}, - }),); + Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), + ValuesIn(std::vector>{ + // The operand literal values are arbitrarily chosen, + // but there are the right number of them. + {CASE(RelaxedPrecision), {}}, + {CASE(SpecId), {100}}, + {CASE(Block), {}}, + {CASE(BufferBlock), {}}, + {CASE(RowMajor), {}}, + {CASE(ColMajor), {}}, + {CASE(ArrayStride), {4}}, + {CASE(MatrixStride), {16}}, + {CASE(GLSLShared), {}}, + {CASE(GLSLPacked), {}}, + {CASE(CPacked), {}}, + // Placeholder line for enum value 12 + {CASE(NoPerspective), {}}, + {CASE(Flat), {}}, + {CASE(Patch), {}}, + {CASE(Centroid), {}}, + {CASE(Sample), {}}, + {CASE(Invariant), {}}, + {CASE(Restrict), {}}, + {CASE(Aliased), {}}, + {CASE(Volatile), {}}, + {CASE(Constant), {}}, + {CASE(Coherent), {}}, + {CASE(NonWritable), {}}, + {CASE(NonReadable), {}}, + {CASE(Uniform), {}}, + {CASE(SaturatedConversion), {}}, + {CASE(Stream), {2}}, + {CASE(Location), {6}}, + {CASE(Component), {3}}, + {CASE(Index), {14}}, + {CASE(Binding), {19}}, + {CASE(DescriptorSet), {7}}, + {CASE(Offset), {12}}, + {CASE(XfbBuffer), {1}}, + {CASE(XfbStride), {8}}, + {CASE(NoContraction), {}}, + {CASE(InputAttachmentIndex), {102}}, + {CASE(Alignment), {16}}, + })), ); + +INSTANTIATE_TEST_CASE_P(TextToBinaryDecorateSimpleV11, OpDecorateSimpleTest, + Combine(Values(SPV_ENV_UNIVERSAL_1_1), + Values(EnumCase{ + CASE(MaxByteOffset), {128}})), ); #undef CASE TEST_F(OpDecorateSimpleTest, WrongDecoration) { @@ -289,8 +304,9 @@ TEST_F(OpDecorateEnumTest, CombinedFPFastMathMask) { } TEST_F(OpDecorateEnumTest, WrongFPFastMathMode) { - EXPECT_THAT(CompileFailure("OpDecorate %1 FPFastMathMode NotNaN|xxyyzz"), - Eq("Invalid floating-point fast math mode operand 'NotNaN|xxyyzz'.")); + EXPECT_THAT( + CompileFailure("OpDecorate %1 FPFastMathMode NotNaN|xxyyzz"), + Eq("Invalid floating-point fast math mode operand 'NotNaN|xxyyzz'.")); } // Test OpDecorate Linkage @@ -394,68 +410,77 @@ TEST_F(TextToBinaryTest, GroupMemberDecorateInvalidSecondTargetMemberNumber) { // Test OpMemberDecorate using OpMemberDecorateSimpleTest = spvtest::TextToBinaryTestBase< - ::testing::TestWithParam>>; + ::testing::TestWithParam>>>; TEST_P(OpMemberDecorateSimpleTest, AnySimpleDecoration) { // This string should assemble, but should not validate. std::stringstream input; - input << "OpMemberDecorate %1 42 " << GetParam().name(); - for (auto operand : GetParam().operands()) input << " " << operand; + input << "OpMemberDecorate %1 42 " << get<1>(GetParam()).name(); + for (auto operand : get<1>(GetParam()).operands()) input << " " << operand; input << std::endl; - EXPECT_THAT(CompiledInstructions(input.str()), + EXPECT_THAT(CompiledInstructions(input.str(), get<0>(GetParam())), Eq(MakeInstruction(SpvOpMemberDecorate, - {1, 42, uint32_t(GetParam().value())}, - GetParam().operands()))); + {1, 42, uint32_t(get<1>(GetParam()).value())}, + get<1>(GetParam()).operands()))); // Also check disassembly. - EXPECT_THAT(EncodeAndDecodeSuccessfully(input.str()), Eq(input.str())); + EXPECT_THAT( + EncodeAndDecodeSuccessfully(input.str(), SPV_BINARY_TO_TEXT_OPTION_NONE, + get<0>(GetParam())), + Eq(input.str())); } #define CASE(NAME) SpvDecoration##NAME, #NAME INSTANTIATE_TEST_CASE_P( TextToBinaryDecorateSimple, OpMemberDecorateSimpleTest, - ::testing::ValuesIn(std::vector>{ - // The operand literal values are arbitrarily chosen, - // but there are the right number of them. - {CASE(RelaxedPrecision), {}}, - {CASE(SpecId), {100}}, - {CASE(Block), {}}, - {CASE(BufferBlock), {}}, - {CASE(RowMajor), {}}, - {CASE(ColMajor), {}}, - {CASE(ArrayStride), {4}}, - {CASE(MatrixStride), {16}}, - {CASE(GLSLShared), {}}, - {CASE(GLSLPacked), {}}, - {CASE(CPacked), {}}, - // Placeholder line for enum value 12 - {CASE(NoPerspective), {}}, - {CASE(Flat), {}}, - {CASE(Patch), {}}, - {CASE(Centroid), {}}, - {CASE(Sample), {}}, - {CASE(Invariant), {}}, - {CASE(Restrict), {}}, - {CASE(Aliased), {}}, - {CASE(Volatile), {}}, - {CASE(Constant), {}}, - {CASE(Coherent), {}}, - {CASE(NonWritable), {}}, - {CASE(NonReadable), {}}, - {CASE(Uniform), {}}, - {CASE(SaturatedConversion), {}}, - {CASE(Stream), {2}}, - {CASE(Location), {6}}, - {CASE(Component), {3}}, - {CASE(Index), {14}}, - {CASE(Binding), {19}}, - {CASE(DescriptorSet), {7}}, - {CASE(Offset), {12}}, - {CASE(XfbBuffer), {1}}, - {CASE(XfbStride), {8}}, - {CASE(NoContraction), {}}, - {CASE(InputAttachmentIndex), {102}}, - {CASE(Alignment), {16}}, - }),); + Combine(Values(SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1), + ValuesIn(std::vector>{ + // The operand literal values are arbitrarily chosen, + // but there are the right number of them. + {CASE(RelaxedPrecision), {}}, + {CASE(SpecId), {100}}, + {CASE(Block), {}}, + {CASE(BufferBlock), {}}, + {CASE(RowMajor), {}}, + {CASE(ColMajor), {}}, + {CASE(ArrayStride), {4}}, + {CASE(MatrixStride), {16}}, + {CASE(GLSLShared), {}}, + {CASE(GLSLPacked), {}}, + {CASE(CPacked), {}}, + // Placeholder line for enum value 12 + {CASE(NoPerspective), {}}, + {CASE(Flat), {}}, + {CASE(Patch), {}}, + {CASE(Centroid), {}}, + {CASE(Sample), {}}, + {CASE(Invariant), {}}, + {CASE(Restrict), {}}, + {CASE(Aliased), {}}, + {CASE(Volatile), {}}, + {CASE(Constant), {}}, + {CASE(Coherent), {}}, + {CASE(NonWritable), {}}, + {CASE(NonReadable), {}}, + {CASE(Uniform), {}}, + {CASE(SaturatedConversion), {}}, + {CASE(Stream), {2}}, + {CASE(Location), {6}}, + {CASE(Component), {3}}, + {CASE(Index), {14}}, + {CASE(Binding), {19}}, + {CASE(DescriptorSet), {7}}, + {CASE(Offset), {12}}, + {CASE(XfbBuffer), {1}}, + {CASE(XfbStride), {8}}, + {CASE(NoContraction), {}}, + {CASE(InputAttachmentIndex), {102}}, + {CASE(Alignment), {16}}, + })), ); + +INSTANTIATE_TEST_CASE_P( + TextToBinaryDecorateSimpleV11, OpMemberDecorateSimpleTest, + Combine(Values(SPV_ENV_UNIVERSAL_1_1), + Values(EnumCase{CASE(MaxByteOffset), {128}})), ); #undef CASE TEST_F(OpMemberDecorateSimpleTest, WrongDecoration) { diff --git a/test/Validate.Capability.cpp b/test/Validate.Capability.cpp index 5d4e96b..6ce3fea 100644 --- a/test/Validate.Capability.cpp +++ b/test/Validate.Capability.cpp @@ -833,6 +833,17 @@ make_pair(string(kGLSL450MemoryModel) + "%intt = OpTypeInt 32 1\n", KernelDependencies()) )),); +// clang-format on +INSTANTIATE_TEST_CASE_P( + DecorationV11, ValidateCapabilityV11, + Combine(ValuesIn(AllCapabilities()), + Values(make_pair(string(kOpenCLMemoryModel) + + "OpDecorate %p MaxByteOffset 0 " + "%i32 = OpTypeInt 32 1 " + "%pi32 = OpTypePointer Workgroup %i32 " + "%p = OpVariable %pi32 Workgroup ", + AddressesDependencies()))), ); +// clang-format off INSTANTIATE_TEST_CASE_P(BuiltIn, ValidateCapability, Combine(