| // Copyright (c) 2018 Google LLC. |
| // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights |
| // reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Tests validation rules of GLSL.450.std and OpenCL.std extended instructions. |
| // Doesn't test OpenCL.std vector size 2, 3, 4, 8 or 16 rules (not supported |
| // by standard SPIR-V). |
| |
| #include <cstring> |
| #include <sstream> |
| #include <string> |
| #include <tuple> |
| #include <utility> |
| #include <vector> |
| |
| #include "gmock/gmock.h" |
| #include "source/spirv_target_env.h" |
| #include "test/unit_spirv.h" |
| #include "test/val/val_code_generator.h" |
| #include "test/val/val_fixtures.h" |
| |
| namespace spvtools { |
| namespace val { |
| namespace { |
| |
| struct TestResult { |
| TestResult(spv_result_t in_validation_result = SPV_SUCCESS, |
| const char* in_error_str = nullptr, |
| const char* in_error_str2 = nullptr) |
| : validation_result(in_validation_result), |
| error_str(in_error_str), |
| error_str2(in_error_str2) {} |
| spv_result_t validation_result; |
| const char* error_str; |
| const char* error_str2; |
| }; |
| |
| using ::testing::Combine; |
| using ::testing::HasSubstr; |
| using ::testing::Not; |
| using ::testing::Values; |
| using ::testing::ValuesIn; |
| |
| using ValidateBuiltIns = spvtest::ValidateBase<bool>; |
| using ValidateVulkanSubgroupBuiltIns = |
| spvtest::ValidateBase<std::tuple<const char*, const char*, const char*, |
| const char*, const char*, TestResult>>; |
| using ValidateVulkanCombineBuiltInExecutionModelDataTypeResult = |
| spvtest::ValidateBase<std::tuple<const char*, const char*, const char*, |
| const char*, const char*, TestResult>>; |
| using ValidateVulkanCombineBuiltInArrayedVariable = |
| spvtest::ValidateBase<std::tuple<const char*, const char*, const char*, |
| const char*, const char*, TestResult>>; |
| using ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult = |
| spvtest::ValidateBase< |
| std::tuple<const char*, const char*, const char*, const char*, |
| const char*, const char*, const char*, TestResult>>; |
| |
| using ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult = |
| spvtest::ValidateBase<std::tuple<spv_target_env, const char*, const char*, |
| const char*, const char*, const char*, |
| const char*, const char*, TestResult>>; |
| |
| bool InitializerRequired(const char* const storage_class) { |
| return (strncmp(storage_class, "Output", 6) == 0 || |
| strncmp(storage_class, "Private", 7) == 0 || |
| strncmp(storage_class, "Function", 8) == 0); |
| } |
| |
| CodeGenerator GetInMainCodeGenerator(const char* const built_in, |
| const char* const execution_model, |
| const char* const storage_class, |
| const char* const capabilities, |
| const char* const extensions, |
| const char* const data_type) { |
| CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); |
| |
| if (capabilities) { |
| generator.capabilities_ += capabilities; |
| } |
| if (extensions) { |
| generator.extensions_ += extensions; |
| } |
| |
| generator.before_types_ = R"(OpDecorate %built_in_type Block |
| OpMemberDecorate %built_in_type 0 BuiltIn )"; |
| generator.before_types_ += built_in; |
| generator.before_types_ += "\n"; |
| |
| std::ostringstream after_types; |
| |
| after_types << "%built_in_type = OpTypeStruct " << data_type << "\n"; |
| if (InitializerRequired(storage_class)) { |
| after_types << "%built_in_null = OpConstantNull %built_in_type\n"; |
| } |
| after_types << "%built_in_ptr = OpTypePointer " << storage_class |
| << " %built_in_type\n"; |
| after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; |
| if (InitializerRequired(storage_class)) { |
| after_types << " %built_in_null"; |
| } |
| after_types << "\n"; |
| after_types << "%data_ptr = OpTypePointer " << storage_class << " " |
| << data_type << "\n"; |
| generator.after_types_ = after_types.str(); |
| |
| EntryPoint entry_point; |
| entry_point.name = "main"; |
| entry_point.execution_model = execution_model; |
| if (strncmp(storage_class, "Input", 5) == 0 || |
| strncmp(storage_class, "Output", 6) == 0) { |
| entry_point.interfaces = "%built_in_var"; |
| } |
| |
| std::ostringstream execution_modes; |
| if (0 == std::strcmp(execution_model, "Fragment")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OriginUpperLeft\n"; |
| if (0 == std::strcmp(built_in, "FragDepth")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " DepthReplacing\n"; |
| } |
| } |
| if (0 == std::strcmp(execution_model, "Geometry")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " InputPoints\n"; |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OutputPoints\n"; |
| } |
| if (0 == std::strcmp(execution_model, "GLCompute")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " LocalSize 1 1 1\n"; |
| } |
| entry_point.execution_modes = execution_modes.str(); |
| |
| entry_point.body = R"( |
| %ptr = OpAccessChain %data_ptr %built_in_var %u32_0 |
| )"; |
| generator.entry_points_.push_back(std::move(entry_point)); |
| |
| return generator; |
| } |
| |
| TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, InMain) { |
| const char* const built_in = std::get<0>(GetParam()); |
| const char* const execution_model = std::get<1>(GetParam()); |
| const char* const storage_class = std::get<2>(GetParam()); |
| const char* const data_type = std::get<3>(GetParam()); |
| const char* const vuid = std::get<4>(GetParam()); |
| const TestResult& test_result = std::get<5>(GetParam()); |
| |
| CodeGenerator generator = GetInMainCodeGenerator( |
| built_in, execution_model, storage_class, NULL, NULL, data_type); |
| |
| CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); |
| ASSERT_EQ(test_result.validation_result, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| TEST_P( |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| InMain) { |
| const char* const built_in = std::get<0>(GetParam()); |
| const char* const execution_model = std::get<1>(GetParam()); |
| const char* const storage_class = std::get<2>(GetParam()); |
| const char* const data_type = std::get<3>(GetParam()); |
| const char* const capabilities = std::get<4>(GetParam()); |
| const char* const extensions = std::get<5>(GetParam()); |
| const char* const vuid = std::get<6>(GetParam()); |
| const TestResult& test_result = std::get<7>(GetParam()); |
| |
| CodeGenerator generator = |
| GetInMainCodeGenerator(built_in, execution_model, storage_class, |
| capabilities, extensions, data_type); |
| |
| CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); |
| ASSERT_EQ(test_result.validation_result, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| TEST_P( |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| InMain) { |
| const spv_target_env env = std::get<0>(GetParam()); |
| const char* const built_in = std::get<1>(GetParam()); |
| const char* const execution_model = std::get<2>(GetParam()); |
| const char* const storage_class = std::get<3>(GetParam()); |
| const char* const data_type = std::get<4>(GetParam()); |
| const char* const capabilities = std::get<5>(GetParam()); |
| const char* const extensions = std::get<6>(GetParam()); |
| const char* const vuid = std::get<7>(GetParam()); |
| const TestResult& test_result = std::get<8>(GetParam()); |
| |
| CodeGenerator generator = |
| GetInMainCodeGenerator(built_in, execution_model, storage_class, |
| capabilities, extensions, data_type); |
| |
| CompileSuccessfully(generator.Build(), env); |
| ASSERT_EQ(test_result.validation_result, ValidateInstructions(env)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| CodeGenerator GetInFunctionCodeGenerator(const char* const built_in, |
| const char* const execution_model, |
| const char* const storage_class, |
| const char* const capabilities, |
| const char* const extensions, |
| const char* const data_type) { |
| CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); |
| |
| if (capabilities) { |
| generator.capabilities_ += capabilities; |
| } |
| if (extensions) { |
| generator.extensions_ += extensions; |
| } |
| |
| generator.before_types_ = R"(OpDecorate %built_in_type Block |
| OpMemberDecorate %built_in_type 0 BuiltIn )"; |
| generator.before_types_ += built_in; |
| generator.before_types_ += "\n"; |
| |
| std::ostringstream after_types; |
| after_types << "%built_in_type = OpTypeStruct " << data_type << "\n"; |
| if (InitializerRequired(storage_class)) { |
| after_types << "%built_in_null = OpConstantNull %built_in_type\n"; |
| } |
| after_types << "%built_in_ptr = OpTypePointer " << storage_class |
| << " %built_in_type\n"; |
| after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; |
| if (InitializerRequired(storage_class)) { |
| after_types << " %built_in_null"; |
| } |
| after_types << "\n"; |
| after_types << "%data_ptr = OpTypePointer " << storage_class << " " |
| << data_type << "\n"; |
| generator.after_types_ = after_types.str(); |
| |
| EntryPoint entry_point; |
| entry_point.name = "main"; |
| entry_point.execution_model = execution_model; |
| if (strncmp(storage_class, "Input", 5) == 0 || |
| strncmp(storage_class, "Output", 6) == 0) { |
| entry_point.interfaces = "%built_in_var"; |
| } |
| |
| std::ostringstream execution_modes; |
| if (0 == std::strcmp(execution_model, "Fragment")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OriginUpperLeft\n"; |
| if (0 == std::strcmp(built_in, "FragDepth")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " DepthReplacing\n"; |
| } |
| } |
| if (0 == std::strcmp(execution_model, "Geometry")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " InputPoints\n"; |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OutputPoints\n"; |
| } |
| if (0 == std::strcmp(execution_model, "GLCompute")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " LocalSize 1 1 1\n"; |
| } |
| entry_point.execution_modes = execution_modes.str(); |
| |
| entry_point.body = R"( |
| %val2 = OpFunctionCall %void %foo |
| )"; |
| |
| std::string function_body = R"( |
| %foo = OpFunction %void None %func |
| %foo_entry = OpLabel |
| %ptr = OpAccessChain %data_ptr %built_in_var %u32_0 |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| generator.add_at_the_end_ = function_body; |
| |
| generator.entry_points_.push_back(std::move(entry_point)); |
| |
| return generator; |
| } |
| |
| TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, InFunction) { |
| const char* const built_in = std::get<0>(GetParam()); |
| const char* const execution_model = std::get<1>(GetParam()); |
| const char* const storage_class = std::get<2>(GetParam()); |
| const char* const data_type = std::get<3>(GetParam()); |
| const char* const vuid = std::get<4>(GetParam()); |
| const TestResult& test_result = std::get<5>(GetParam()); |
| |
| CodeGenerator generator = GetInFunctionCodeGenerator( |
| built_in, execution_model, storage_class, NULL, NULL, data_type); |
| |
| CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); |
| ASSERT_EQ(test_result.validation_result, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| TEST_P( |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| InFunction) { |
| const char* const built_in = std::get<0>(GetParam()); |
| const char* const execution_model = std::get<1>(GetParam()); |
| const char* const storage_class = std::get<2>(GetParam()); |
| const char* const data_type = std::get<3>(GetParam()); |
| const char* const capabilities = std::get<4>(GetParam()); |
| const char* const extensions = std::get<5>(GetParam()); |
| const char* const vuid = std::get<6>(GetParam()); |
| const TestResult& test_result = std::get<7>(GetParam()); |
| |
| CodeGenerator generator = |
| GetInFunctionCodeGenerator(built_in, execution_model, storage_class, |
| capabilities, extensions, data_type); |
| |
| CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); |
| ASSERT_EQ(test_result.validation_result, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| CodeGenerator GetVariableCodeGenerator(const char* const built_in, |
| const char* const execution_model, |
| const char* const storage_class, |
| const char* const capabilities, |
| const char* const extensions, |
| const char* const data_type) { |
| CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); |
| |
| if (capabilities) { |
| generator.capabilities_ += capabilities; |
| } |
| if (extensions) { |
| generator.extensions_ += extensions; |
| } |
| |
| generator.before_types_ = "OpDecorate %built_in_var BuiltIn "; |
| generator.before_types_ += built_in; |
| generator.before_types_ += "\n"; |
| if ((0 == std::strcmp(storage_class, "Input")) && |
| (0 == std::strcmp(execution_model, "Fragment"))) { |
| // ensure any needed input types that might require Flat |
| generator.before_types_ += "OpDecorate %built_in_var Flat\n"; |
| } |
| |
| std::ostringstream after_types; |
| if (InitializerRequired(storage_class)) { |
| after_types << "%built_in_null = OpConstantNull " << data_type << "\n"; |
| } |
| after_types << "%built_in_ptr = OpTypePointer " << storage_class << " " |
| << data_type << "\n"; |
| after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; |
| if (InitializerRequired(storage_class)) { |
| after_types << " %built_in_null"; |
| } |
| after_types << "\n"; |
| generator.after_types_ = after_types.str(); |
| |
| EntryPoint entry_point; |
| entry_point.name = "main"; |
| entry_point.execution_model = execution_model; |
| if (strncmp(storage_class, "Input", 5) == 0 || |
| strncmp(storage_class, "Output", 6) == 0) { |
| entry_point.interfaces = "%built_in_var"; |
| } |
| // Any kind of reference would do. |
| entry_point.body = R"( |
| %val = OpBitcast %u32 %built_in_var |
| )"; |
| |
| std::ostringstream execution_modes; |
| if (0 == std::strcmp(execution_model, "Fragment")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OriginUpperLeft\n"; |
| if (0 == std::strcmp(built_in, "FragDepth")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " DepthReplacing\n"; |
| } |
| } |
| if (0 == std::strcmp(execution_model, "Geometry")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " InputPoints\n"; |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OutputPoints\n"; |
| } |
| if (0 == std::strcmp(execution_model, "GLCompute")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " LocalSize 1 1 1\n"; |
| } |
| entry_point.execution_modes = execution_modes.str(); |
| |
| generator.entry_points_.push_back(std::move(entry_point)); |
| |
| return generator; |
| } |
| |
| TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Variable) { |
| const char* const built_in = std::get<0>(GetParam()); |
| const char* const execution_model = std::get<1>(GetParam()); |
| const char* const storage_class = std::get<2>(GetParam()); |
| const char* const data_type = std::get<3>(GetParam()); |
| const char* const vuid = std::get<4>(GetParam()); |
| const TestResult& test_result = std::get<5>(GetParam()); |
| |
| CodeGenerator generator = GetVariableCodeGenerator( |
| built_in, execution_model, storage_class, NULL, NULL, data_type); |
| |
| CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); |
| ASSERT_EQ(test_result.validation_result, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| TEST_P( |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Variable) { |
| const char* const built_in = std::get<0>(GetParam()); |
| const char* const execution_model = std::get<1>(GetParam()); |
| const char* const storage_class = std::get<2>(GetParam()); |
| const char* const data_type = std::get<3>(GetParam()); |
| const char* const capabilities = std::get<4>(GetParam()); |
| const char* const extensions = std::get<5>(GetParam()); |
| const char* const vuid = std::get<6>(GetParam()); |
| const TestResult& test_result = std::get<7>(GetParam()); |
| |
| CodeGenerator generator = |
| GetVariableCodeGenerator(built_in, execution_model, storage_class, |
| capabilities, extensions, data_type); |
| |
| CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); |
| ASSERT_EQ(test_result.validation_result, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceOutputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), |
| Values("Vertex", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Output"), Values("%f32arr2", "%f32arr4"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceInputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), |
| Values("Fragment", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%f32arr2", "%f32arr4"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceInvalidStorageClass, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), |
| Values("Vertex", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Private"), Values("%f32arr2", "%f32arr4"), |
| Values("VUID-ClipDistance-ClipDistance-04190 " |
| "VUID-CullDistance-CullDistance-04199"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input or Output storage " |
| "class.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceFragmentOutput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), |
| Values("Output"), Values("%f32arr4"), |
| Values("VUID-ClipDistance-ClipDistance-04189 " |
| "VUID-CullDistance-CullDistance-04198"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance " |
| "to be used for variables with Output storage class if " |
| "execution model is Fragment.", |
| "which is called with execution model Fragment.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| VertexIdVertexInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("VertexId"), Values("Vertex"), Values("Input"), Values("%u32"), |
| Values(nullptr), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow BuiltIn VertexId to be " |
| "used.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceVertexInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), Values("Vertex"), |
| Values("Input"), Values("%f32arr4"), |
| Values("VUID-ClipDistance-ClipDistance-04188 " |
| "VUID-CullDistance-CullDistance-04197"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance " |
| "to be used for variables with Input storage class if " |
| "execution model is Vertex.", |
| "which is called with execution model Vertex.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), Values("GLCompute"), |
| Values("Input", "Output"), Values("%f32arr4"), |
| Values("VUID-ClipDistance-ClipDistance-04187 " |
| "VUID-CullDistance-CullDistance-04196"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment, Vertex, TessellationControl, " |
| "TessellationEvaluation or Geometry execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceNotArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), |
| Values("Input"), Values("%f32vec2", "%f32vec4", "%f32"), |
| Values("VUID-ClipDistance-ClipDistance-04191 " |
| "VUID-CullDistance-CullDistance-04200"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float array", |
| "is not an array")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceNotFloatArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), |
| Values("Input"), Values("%u32arr2", "%u64arr4"), |
| Values("VUID-ClipDistance-ClipDistance-04191 " |
| "VUID-CullDistance-CullDistance-04200"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float array", |
| "components are not float scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ClipAndCullDistanceNotF32Array, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"), |
| Values("Input"), Values("%f64arr2", "%f64arr4"), |
| Values("VUID-ClipDistance-ClipDistance-04191 " |
| "VUID-CullDistance-CullDistance-04200"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float array", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32vec4"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragCoordNotFragment, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("FragCoord"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%f32vec4"), |
| Values("VUID-FragCoord-FragCoord-04210"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragCoord"), Values("Fragment"), Values("Output"), |
| Values("%f32vec4"), Values("VUID-FragCoord-FragCoord-04211"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragCoordNotFloatVector, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32arr4", "%u32vec4"), |
| Values("VUID-FragCoord-FragCoord-04212"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float vector", |
| "is not a float vector")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragCoordNotFloatVec4, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32vec3"), Values("VUID-FragCoord-FragCoord-04212"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float vector", |
| "has 3 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragCoordNotF32Vec4, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragCoord"), Values("Fragment"), Values("Input"), |
| Values("%f64vec4"), Values("VUID-FragCoord-FragCoord-04212"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float vector", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragDepthSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragDepth"), Values("Fragment"), Values("Output"), |
| Values("%f32"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragDepthNotFragment, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("FragDepth"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Output"), Values("%f32"), |
| Values("VUID-FragDepth-FragDepth-04213"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragDepthNotOutput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragDepth"), Values("Fragment"), Values("Input"), |
| Values("%f32"), Values("VUID-FragDepth-FragDepth-04214"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Output storage class", |
| "uses storage class Input")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragDepthNotFloatScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragDepth"), Values("Fragment"), Values("Output"), |
| Values("%f32vec4", "%u32"), |
| Values("VUID-FragDepth-FragDepth-04215"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "is not a float scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FragDepthNotF32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FragDepth"), Values("Fragment"), Values("Output"), |
| Values("%f64"), Values("VUID-FragDepth-FragDepth-04215"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FrontFacingAndHelperInvocationSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"), |
| Values("Input"), Values("%bool"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FrontFacingAndHelperInvocationNotFragment, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("FrontFacing", "HelperInvocation"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%bool"), |
| Values("VUID-FrontFacing-FrontFacing-04229 " |
| "VUID-HelperInvocation-HelperInvocation-04239"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FrontFacingAndHelperInvocationNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"), |
| Values("Output"), Values("%bool"), |
| Values("VUID-FrontFacing-FrontFacing-04230 " |
| "VUID-HelperInvocation-HelperInvocation-04240"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| FrontFacingAndHelperInvocationNotBool, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"), |
| Values("Input"), Values("%f32", "%u32"), |
| Values("VUID-FrontFacing-FrontFacing-04231 " |
| "VUID-HelperInvocation-HelperInvocation-04241"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a bool scalar", |
| "is not a bool scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ComputeShaderInputInt32Vec3Success, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", |
| "WorkgroupId"), |
| Values("GLCompute"), Values("Input"), Values("%u32vec3"), |
| Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ComputeShaderInputInt32Vec3NotGLCompute, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", |
| "WorkgroupId"), |
| Values("Vertex", "Fragment", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32vec3"), |
| Values("VUID-GlobalInvocationId-GlobalInvocationId-04236 " |
| "VUID-LocalInvocationId-LocalInvocationId-04281 " |
| "VUID-NumWorkgroups-NumWorkgroups-04296 " |
| "VUID-WorkgroupId-WorkgroupId-04422"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with GLCompute, MeshNV, " |
| "TaskNV, MeshEXT or TaskEXT execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ComputeShaderInputInt32Vec3NotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", |
| "WorkgroupId"), |
| Values("GLCompute"), Values("Output"), Values("%u32vec3"), |
| Values("VUID-GlobalInvocationId-GlobalInvocationId-04237 " |
| "VUID-LocalInvocationId-LocalInvocationId-04282 " |
| "VUID-NumWorkgroups-NumWorkgroups-04297 " |
| "VUID-WorkgroupId-WorkgroupId-04423"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ComputeShaderInputInt32Vec3NotIntVector, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", |
| "WorkgroupId"), |
| Values("GLCompute"), Values("Input"), |
| Values("%u32arr3", "%f32vec3"), |
| Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 " |
| "VUID-LocalInvocationId-LocalInvocationId-04283 " |
| "VUID-NumWorkgroups-NumWorkgroups-04298 " |
| "VUID-WorkgroupId-WorkgroupId-04424"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit int vector", |
| "is not an int vector")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ComputeShaderInputInt32Vec3NotIntVec3, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", |
| "WorkgroupId"), |
| Values("GLCompute"), Values("Input"), Values("%u32vec4"), |
| Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 " |
| "VUID-LocalInvocationId-LocalInvocationId-04283 " |
| "VUID-NumWorkgroups-NumWorkgroups-04298 " |
| "VUID-WorkgroupId-WorkgroupId-04424"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit int vector", |
| "has 4 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ComputeShaderInputInt32Vec3NotInt32Vec, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups", |
| "WorkgroupId"), |
| Values("GLCompute"), Values("Input"), Values("%u64vec3"), |
| Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 " |
| "VUID-LocalInvocationId-LocalInvocationId-04283 " |
| "VUID-NumWorkgroups-NumWorkgroups-04298 " |
| "VUID-WorkgroupId-WorkgroupId-04424"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit int vector", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvocationIdSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), |
| Values("Input"), Values("%u32"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvocationIdInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InvocationId"), |
| Values("Vertex", "Fragment", "GLCompute", "TessellationEvaluation"), |
| Values("Input"), Values("%u32"), |
| Values("VUID-InvocationId-InvocationId-04257"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with TessellationControl or " |
| "Geometry execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvocationIdNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), |
| Values("Output"), Values("%u32"), |
| Values("VUID-InvocationId-InvocationId-04258"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvocationIdNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("VUID-InvocationId-InvocationId-04259"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvocationIdNotInt32, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"), |
| Values("Input"), Values("%u64"), |
| Values("VUID-InvocationId-InvocationId-04259"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InstanceIndexSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"), |
| Values("%u32"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InstanceIndexInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InstanceIndex"), |
| Values("Geometry", "Fragment", "GLCompute", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32"), |
| Values("VUID-InstanceIndex-InstanceIndex-04263"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Vertex execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InstanceIndexNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InstanceIndex"), Values("Vertex"), Values("Output"), |
| Values("%u32"), Values("VUID-InstanceIndex-InstanceIndex-04264"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InstanceIndexNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"), |
| Values("%f32", "%u32vec3"), |
| Values("VUID-InstanceIndex-InstanceIndex-04265"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InstanceIndexNotInt32, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"), |
| Values("%u64"), Values("VUID-InstanceIndex-InstanceIndex-04265"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerAndViewportIndexInputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Layer", "ViewportIndex"), Values("Fragment"), |
| Values("Input"), Values("%u32"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerAndViewportIndexOutputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Layer", "ViewportIndex"), Values("Geometry"), |
| Values("Output"), Values("%u32"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerAndViewportIndexInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("Layer", "ViewportIndex"), |
| Values("TessellationControl", "GLCompute"), Values("Input"), |
| Values("%u32"), |
| Values("VUID-Layer-Layer-04272 VUID-ViewportIndex-ViewportIndex-04404"), |
| Values( |
| TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Vertex, TessellationEvaluation, " |
| "Geometry, or Fragment execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ViewportIndexExecutionModelEnabledByCapability, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("ViewportIndex"), Values("Vertex", "TessellationEvaluation"), |
| Values("Output"), Values("%u32"), |
| Values("VUID-ViewportIndex-ViewportIndex-04405"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "ShaderViewportIndexLayerEXT or ShaderViewportIndex")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerExecutionModelEnabledByCapability, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Layer"), Values("Vertex", "TessellationEvaluation"), |
| Values("Output"), Values("%u32"), Values("VUID-Layer-Layer-04273"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "ShaderViewportIndexLayerEXT or ShaderLayer")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerAndViewportIndexFragmentNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Output"), |
| Values("%u32"), |
| Values("VUID-Layer-Layer-04275 VUID-ViewportIndex-ViewportIndex-04407"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Output storage class if execution model is Fragment", |
| "which is called with execution model Fragment")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerAndViewportIndexGeometryNotOutput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("Layer", "ViewportIndex"), |
| Values("Vertex", "TessellationEvaluation", "Geometry"), Values("Input"), |
| Values("%u32"), |
| Values("VUID-Layer-Layer-04274 VUID-ViewportIndex-ViewportIndex-04406"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Input storage class if execution model is Vertex, " |
| "TessellationEvaluation, Geometry, MeshNV or MeshEXT", |
| "which is called with execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerAndViewportIndexNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Input"), |
| Values("%f32", "%u32vec3"), |
| Values("VUID-Layer-Layer-04276 VUID-ViewportIndex-ViewportIndex-04408"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerAndViewportIndexNotInt32, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Input"), |
| Values("%u64"), |
| Values("VUID-Layer-Layer-04276 VUID-ViewportIndex-ViewportIndex-04408"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LayerCapability, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("Layer"), Values("Vertex"), |
| Values("Output"), Values("%u32"), |
| Values("OpCapability ShaderLayer\n"), Values(nullptr), |
| Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ViewportIndexCapability, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("ViewportIndex"), |
| Values("Vertex"), Values("Output"), Values("%u32"), |
| Values("OpCapability ShaderViewportIndex\n"), Values(nullptr), |
| Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PatchVerticesSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PatchVertices"), |
| Values("TessellationEvaluation", "TessellationControl"), |
| Values("Input"), Values("%u32"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PatchVerticesInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PatchVertices"), |
| Values("Vertex", "Fragment", "GLCompute", "Geometry"), |
| Values("Input"), Values("%u32"), |
| Values("VUID-PatchVertices-PatchVertices-04308"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with TessellationControl or " |
| "TessellationEvaluation execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PatchVerticesNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PatchVertices"), |
| Values("TessellationEvaluation", "TessellationControl"), |
| Values("Output"), Values("%u32"), |
| Values("VUID-PatchVertices-PatchVertices-04309"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PatchVerticesNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PatchVertices"), |
| Values("TessellationEvaluation", "TessellationControl"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("VUID-PatchVertices-PatchVertices-04310"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PatchVerticesNotInt32, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PatchVertices"), |
| Values("TessellationEvaluation", "TessellationControl"), |
| Values("Input"), Values("%u64"), |
| Values("VUID-PatchVertices-PatchVertices-04310"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32vec2"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointCoordNotFragment, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("PointCoord"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%f32vec2"), |
| Values("VUID-PointCoord-PointCoord-04311"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointCoordNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointCoord"), Values("Fragment"), Values("Output"), |
| Values("%f32vec2"), Values("VUID-PointCoord-PointCoord-04312"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointCoordNotFloatVector, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32arr2", "%u32vec2"), |
| Values("VUID-PointCoord-PointCoord-04313"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float vector", |
| "is not a float vector")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointCoordNotFloatVec3, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32vec3"), Values("VUID-PointCoord-PointCoord-04313"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float vector", |
| "has 3 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointCoordNotF32Vec4, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointCoord"), Values("Fragment"), Values("Input"), |
| Values("%f64vec2"), Values("VUID-PointCoord-PointCoord-04313"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float vector", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeOutputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointSize"), |
| Values("Vertex", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Output"), Values("%f32"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeInputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointSize"), |
| Values("Geometry", "TessellationControl", "TessellationEvaluation"), |
| Values("Input"), Values("%f32"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeVertexInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointSize"), Values("Vertex"), Values("Input"), |
| Values("%f32"), Values("VUID-PointSize-PointSize-04315"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow BuiltIn PointSize " |
| "to be used for variables with Input storage class if " |
| "execution model is Vertex.", |
| "which is called with execution model Vertex.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointSize"), Values("GLCompute", "Fragment"), |
| Values("Input", "Output"), Values("%f32"), |
| Values("VUID-PointSize-PointSize-04314"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be used only with Vertex, TessellationControl, " |
| "TessellationEvaluation or Geometry execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeNotFloatScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointSize"), Values("Vertex"), Values("Output"), |
| Values("%f32vec4", "%u32"), |
| Values("VUID-PointSize-PointSize-04317"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "is not a float scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeNotF32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PointSize"), Values("Vertex"), Values("Output"), |
| Values("%f64"), Values("VUID-PointSize-PointSize-04317"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionOutputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), |
| Values("Vertex", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Output"), Values("%f32vec4"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionInputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), |
| Values("Geometry", "TessellationControl", "TessellationEvaluation"), |
| Values("Input"), Values("%f32vec4"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionInvalidStorageClass, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), |
| Values("Geometry", "TessellationControl", "TessellationEvaluation"), |
| Values("Private"), Values("%f32vec4"), |
| Values("VUID-Position-Position-04320"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec allows BuiltIn Position to be only used for " |
| "variables with Input or Output storage class.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionVertexInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), Values("Vertex"), Values("Input"), |
| Values("%f32vec4"), Values("VUID-Position-Position-04319"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow BuiltIn Position " |
| "to be used for variables with Input storage class if " |
| "execution model is Vertex.", |
| "which is called with execution model Vertex.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), Values("GLCompute", "Fragment"), |
| Values("Input", "Output"), Values("%f32vec4"), |
| Values("VUID-Position-Position-04318"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be used only with Vertex, TessellationControl, " |
| "TessellationEvaluation or Geometry execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionNotFloatVector, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), Values("Geometry"), Values("Input"), |
| Values("%f32arr4", "%u32vec4"), |
| Values("VUID-Position-Position-04321"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float vector", |
| "is not a float vector")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionNotFloatVec4, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), Values("Geometry"), Values("Input"), |
| Values("%f32vec3"), Values("VUID-Position-Position-04321"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float vector", |
| "has 3 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PositionNotF32Vec4, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("Position"), Values("Geometry"), Values("Input"), |
| Values("%f64vec4"), Values("VUID-Position-Position-04321"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float vector", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdInputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PrimitiveId"), |
| Values("Fragment", "TessellationControl", "TessellationEvaluation", |
| "Geometry"), |
| Values("Input"), Values("%u32"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdOutputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PrimitiveId"), Values("Geometry"), Values("Output"), |
| Values("%u32"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("PrimitiveId"), Values("Vertex", "GLCompute"), Values("Input"), |
| Values("%u32"), Values("VUID-PrimitiveId-PrimitiveId-04330"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment, TessellationControl, " |
| "TessellationEvaluation, Geometry, MeshNV, MeshEXT, " |
| "IntersectionKHR, " |
| "AnyHitKHR, and ClosestHitKHR execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdFragmentNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("PrimitiveId"), Values("Fragment"), Values("Output"), |
| Values("%u32"), Values("VUID-PrimitiveId-PrimitiveId-04334"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Output storage class if execution model is Fragment", |
| "which is called with execution model Fragment")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdTessellationNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PrimitiveId"), |
| Values("TessellationControl", "TessellationEvaluation"), |
| Values("Output"), Values("%u32"), |
| Values("VUID-PrimitiveId-PrimitiveId-04334"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Output storage class if execution model is Tessellation", |
| "which is called with execution model Tessellation")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PrimitiveId"), Values("Fragment"), Values("Input"), |
| Values("%f32", "%u32vec3"), |
| Values("VUID-PrimitiveId-PrimitiveId-04337"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdNotInt32, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("PrimitiveId"), Values("Fragment"), Values("Input"), |
| Values("%u64"), Values("VUID-PrimitiveId-PrimitiveId-04337"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleIdSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleId"), Values("Fragment"), Values("Input"), |
| Values("%u32"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleIdInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("SampleId"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32"), Values("VUID-SampleId-SampleId-04354"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleIdNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("SampleId"), Values("Fragment"), Values("Output"), |
| Values("%u32"), Values("VUID-SampleId-SampleId-04355"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec allows BuiltIn SampleId to be only used " |
| "for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleIdNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleId"), Values("Fragment"), Values("Input"), |
| Values("%f32", "%u32vec3"), Values("VUID-SampleId-SampleId-04356"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleIdNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleId"), Values("Fragment"), Values("Input"), |
| Values("%u64"), Values("VUID-SampleId-SampleId-04356"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleMaskSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleMask"), Values("Fragment"), Values("Input", "Output"), |
| Values("%u32arr2", "%u32arr4"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleMaskInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("SampleMask"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32arr2"), |
| Values("VUID-SampleMask-SampleMask-04357"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleMaskWrongStorageClass, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleMask"), Values("Fragment"), Values("Workgroup"), |
| Values("%u32arr2"), Values("VUID-SampleMask-SampleMask-04358"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec allows BuiltIn SampleMask to be only used for " |
| "variables with Input or Output storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleMaskNotArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleMask"), Values("Fragment"), Values("Input"), |
| Values("%f32", "%u32vec3"), |
| Values("VUID-SampleMask-SampleMask-04359"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int array", |
| "is not an array")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleMaskNotIntArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleMask"), Values("Fragment"), Values("Input"), |
| Values("%f32arr2"), Values("VUID-SampleMask-SampleMask-04359"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int array", |
| "components are not int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SampleMaskNotInt32Array, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SampleMask"), Values("Fragment"), Values("Input"), |
| Values("%u64arr2"), Values("VUID-SampleMask-SampleMask-04359"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int array", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SamplePositionSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), |
| Values("%f32vec2"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SamplePositionNotFragment, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("SamplePosition"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%f32vec2"), |
| Values("VUID-SamplePosition-SamplePosition-04360"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SamplePositionNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SamplePosition"), Values("Fragment"), Values("Output"), |
| Values("%f32vec2"), |
| Values("VUID-SamplePosition-SamplePosition-04361"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SamplePositionNotFloatVector, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), |
| Values("%f32arr2", "%u32vec4"), |
| Values("VUID-SamplePosition-SamplePosition-04362"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float vector", |
| "is not a float vector")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SamplePositionNotFloatVec2, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), |
| Values("%f32vec3"), |
| Values("VUID-SamplePosition-SamplePosition-04362"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float vector", |
| "has 3 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| SamplePositionNotF32Vec2, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"), |
| Values("%f64vec2"), |
| Values("VUID-SamplePosition-SamplePosition-04362"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float vector", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessCoord"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f32vec3"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessCoordNotFragment, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("TessCoord"), |
| Values("Vertex", "GLCompute", "Geometry", "TessellationControl", |
| "Fragment"), |
| Values("Input"), Values("%f32vec3"), |
| Values("VUID-TessCoord-TessCoord-04387"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be used only with TessellationEvaluation execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessCoord"), Values("Fragment"), Values("Output"), |
| Values("%f32vec3"), Values("VUID-TessCoord-TessCoord-04388"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be only used for variables with Input storage class", |
| "uses storage class Output")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessCoordNotFloatVector, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32arr3", "%u32vec4"), |
| Values("VUID-TessCoord-TessCoord-04389"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit float vector", |
| "is not a float vector")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessCoordNotFloatVec3, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessCoord"), Values("Fragment"), Values("Input"), |
| Values("%f32vec2"), Values("VUID-TessCoord-TessCoord-04389"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit float vector", |
| "has 2 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessCoordNotF32Vec3, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessCoord"), Values("Fragment"), Values("Input"), |
| Values("%f64vec3"), Values("VUID-TessCoord-TessCoord-04389"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit float vector", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterTeseInputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f32arr4"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterTescOutputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationControl"), |
| Values("Output"), Values("%f32arr4"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), |
| Values("Vertex", "GLCompute", "Geometry", "Fragment"), |
| Values("Input"), Values("%f32arr4"), |
| Values("VUID-TessLevelOuter-TessLevelOuter-04390"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with TessellationControl or " |
| "TessellationEvaluation execution models.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterOutputTese, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), |
| Values("Output"), Values("%f32arr4"), |
| Values("VUID-TessLevelOuter-TessLevelOuter-04392"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " |
| "used for variables with Output storage class if execution " |
| "model is TessellationEvaluation.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterInputTesc, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationControl"), |
| Values("Input"), Values("%f32arr4"), |
| Values("VUID-TessLevelOuter-TessLevelOuter-04391"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " |
| "used for variables with Input storage class if execution " |
| "model is TessellationControl.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterNotArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f32vec4", "%f32"), |
| Values("VUID-TessLevelOuter-TessLevelOuter-04393"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float array", |
| "is not an array")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterNotFloatArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%u32arr4"), |
| Values("VUID-TessLevelOuter-TessLevelOuter-04393"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float array", |
| "components are not float scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterNotFloatArr4, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f32arr3"), |
| Values("VUID-TessLevelOuter-TessLevelOuter-04393"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float array", |
| "has 3 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelOuterNotF32Arr4, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f64arr4"), |
| Values("VUID-TessLevelOuter-TessLevelOuter-04393"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 4-component 32-bit float array", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerTeseInputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f32arr2"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerTescOutputSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationControl"), |
| Values("Output"), Values("%f32arr2"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), |
| Values("Vertex", "GLCompute", "Geometry", "Fragment"), |
| Values("Input"), Values("%f32arr2"), |
| Values("VUID-TessLevelInner-TessLevelInner-04394"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with TessellationControl or " |
| "TessellationEvaluation execution models.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerOutputTese, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), |
| Values("Output"), Values("%f32arr2"), |
| Values("VUID-TessLevelInner-TessLevelInner-04396"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " |
| "used for variables with Output storage class if execution " |
| "model is TessellationEvaluation.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerInputTesc, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationControl"), |
| Values("Input"), Values("%f32arr2"), |
| Values("VUID-TessLevelInner-TessLevelInner-04395"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be " |
| "used for variables with Input storage class if execution " |
| "model is TessellationControl.")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerNotArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f32vec2", "%f32"), |
| Values("VUID-TessLevelInner-TessLevelInner-04397"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float array", |
| "is not an array")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerNotFloatArray, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%u32arr2"), |
| Values("VUID-TessLevelInner-TessLevelInner-04397"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float array", |
| "components are not float scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerNotFloatArr2, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f32arr3"), |
| Values("VUID-TessLevelInner-TessLevelInner-04397"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float array", |
| "has 3 components")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| TessLevelInnerNotF32Arr2, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("TessLevelInner"), Values("TessellationEvaluation"), |
| Values("Input"), Values("%f64arr2"), |
| Values("VUID-TessLevelInner-TessLevelInner-04397"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 2-component 32-bit float array", |
| "has components with bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| VertexIndexSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"), |
| Values("%u32"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| VertexIndexInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("VertexIndex"), |
| Values("Fragment", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32"), |
| Values("VUID-VertexIndex-VertexIndex-04398"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Vertex execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| VertexIndexNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine( |
| Values("VertexIndex"), Values("Vertex"), Values("Output"), |
| Values("%u32"), Values("VUID-VertexIndex-VertexIndex-04399"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec allows BuiltIn VertexIndex to be only " |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| VertexIndexNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"), |
| Values("%f32", "%u32vec3"), |
| Values("VUID-VertexIndex-VertexIndex-04400"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| VertexIndexNotInt32, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, |
| Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"), |
| Values("%u64"), Values("VUID-VertexIndex-VertexIndex-04400"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| BaseInstanceOrVertexSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| BaseInstanceOrVertexInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("BaseInstance", "BaseVertex"), |
| Values("Fragment", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values("VUID-BaseInstance-BaseInstance-04181 " |
| "VUID-BaseVertex-BaseVertex-04184"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Vertex execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| BaseInstanceOrVertexNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"), |
| Values("Output"), Values("%u32"), |
| Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values("VUID-BaseInstance-BaseInstance-04182 " |
| "VUID-BaseVertex-BaseVertex-04185"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| BaseInstanceOrVertexNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values("VUID-BaseInstance-BaseInstance-04183 " |
| "VUID-BaseVertex-BaseVertex-04186"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DrawIndexSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("DrawIndex"), Values("Vertex"), Values("Input"), |
| Values("%u32"), Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DrawIndexMeshSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine( |
| Values("DrawIndex"), Values("MeshNV", "TaskNV"), Values("Input"), |
| Values("%u32"), Values("OpCapability MeshShadingNV\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\nOpExtension " |
| "\"SPV_NV_mesh_shader\"\n"), |
| Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DrawIndexInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine( |
| Values("DrawIndex"), |
| Values("Fragment", "GLCompute", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values("VUID-DrawIndex-DrawIndex-04207"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be used only with Vertex, MeshNV, TaskNV , MeshEXT or TaskEXT " |
| "execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DrawIndexNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("DrawIndex"), Values("Vertex"), Values("Output"), |
| Values("%u32"), Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values("VUID-DrawIndex-DrawIndex-04208"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DrawIndexNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("DrawIndex"), Values("Vertex"), Values("Input"), |
| Values("%f32", "%u32vec3"), Values("OpCapability DrawParameters\n"), |
| Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"), |
| Values("VUID-DrawIndex-DrawIndex-04209"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ViewIndexSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("ViewIndex"), |
| Values("Fragment", "Vertex", "Geometry", "TessellationControl", |
| "TessellationEvaluation"), |
| Values("Input"), Values("%u32"), Values("OpCapability MultiView\n"), |
| Values("OpExtension \"SPV_KHR_multiview\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ViewIndexInvalidExecutionModel, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("ViewIndex"), Values("GLCompute"), Values("Input"), |
| Values("%u32"), Values("OpCapability MultiView\n"), |
| Values("OpExtension \"SPV_KHR_multiview\"\n"), |
| Values("VUID-ViewIndex-ViewIndex-04401"), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "to be not be used with GLCompute execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ViewIndexNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("ViewIndex"), Values("Vertex"), Values("Output"), |
| Values("%u32"), Values("OpCapability MultiView\n"), |
| Values("OpExtension \"SPV_KHR_multiview\"\n"), |
| Values("VUID-ViewIndex-ViewIndex-04402"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ViewIndexNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("ViewIndex"), Values("Vertex"), Values("Input"), |
| Values("%f32", "%u32vec3"), Values("OpCapability MultiView\n"), |
| Values("OpExtension \"SPV_KHR_multiview\"\n"), |
| Values("VUID-ViewIndex-ViewIndex-04403"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DeviceIndexSuccess, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("DeviceIndex"), |
| Values("Fragment", "Vertex", "Geometry", "TessellationControl", |
| "TessellationEvaluation", "GLCompute"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability DeviceGroup\n"), |
| Values("OpExtension \"SPV_KHR_device_group\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DeviceIndexNotInput, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("DeviceIndex"), Values("Fragment", "Vertex", "GLCompute"), |
| Values("Output"), Values("%u32"), |
| Values("OpCapability DeviceGroup\n"), |
| Values("OpExtension \"SPV_KHR_device_group\"\n"), |
| Values("VUID-DeviceIndex-DeviceIndex-04205"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| DeviceIndexNotIntScalar, |
| ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values("DeviceIndex"), Values("Fragment", "Vertex", "GLCompute"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("OpCapability DeviceGroup\n"), |
| Values("OpExtension \"SPV_KHR_device_group\"\n"), |
| Values("VUID-DeviceIndex-DeviceIndex-04206"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| // Test HitKind in NV RT shaders |
| INSTANTIATE_TEST_SUITE_P( |
| HitKindNVSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindNV"), |
| Values("AnyHitNV", "ClosestHitNV"), Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingNV\n"), |
| Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| // HitKind is valid in AH, CH shaders as input i32 scalar |
| INSTANTIATE_TEST_SUITE_P( |
| HitKindSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"), |
| Values("%u32"), Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| HitKindNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "IntersectionKHR", |
| "MissKHR", "CallableKHR"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-HitKindKHR-HitKindKHR-04242"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| HitKindNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR"), Values("Output"), |
| Values("%u32"), Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-HitKindKHR-HitKindKHR-04243"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| HitKindNotIntScalar, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"), |
| Values("%f32", "%u32vec3"), Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-HitKindKHR-HitKindKHR-04244"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| // Ensure HitT is not supported in KHR RT shaders |
| INSTANTIATE_TEST_SUITE_P( |
| HitTNVNotSupportedInKHR, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), |
| Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"), |
| Values("%u32"), Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult( |
| SPV_ERROR_INVALID_CAPABILITY, |
| "of MemberDecorate requires one of these capabilities")))); |
| |
| // HitT is valid in AH, CH shaders as input f32 scalar (NV RT only) |
| INSTANTIATE_TEST_SUITE_P( |
| HitTNVSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), |
| Values("AnyHitNV", "ClosestHitNV"), Values("Input"), Values("%f32"), |
| Values("OpCapability RayTracingNV\n"), |
| Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| HitTNVNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationNV", "IntersectionNV", "MissNV", |
| "CallableNV"), |
| Values("Input"), Values("%f32"), |
| Values("OpCapability RayTracingNV\n"), |
| Values("OpExtension \"SPV_NV_ray_tracing\"\n"), |
| Values("VUID-HitTNV-HitTNV-04245"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| HitTNVNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), |
| Values("AnyHitNV", "ClosestHitNV"), Values("Output"), |
| Values("%f32"), Values("OpCapability RayTracingNV\n"), |
| Values("OpExtension \"SPV_NV_ray_tracing\"\n"), |
| Values("VUID-HitTNV-HitTNV-04246"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| INSTANTIATE_TEST_SUITE_P( |
| HitTNVNotIntScalar, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"), |
| Values("AnyHitNV", "ClosestHitNV"), Values("Input"), |
| Values("%u32", "%f32vec3"), Values("OpCapability RayTracingNV\n"), |
| Values("OpExtension \"SPV_NV_ray_tracing\"\n"), |
| Values("VUID-HitTNV-HitTNV-04247"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "is not a float scalar")))); |
| |
| // InstanceCustomIndexKHR, InstanceId, PrimitiveId, RayGeometryIndexKHR are |
| // valid in IS, AH, CH shaders as input i32 scalars |
| INSTANTIATE_TEST_SUITE_P( |
| RTBuiltIn3StageI32Success, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", |
| "InstanceId", "PrimitiveId"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RTBuiltIn3StageI32NotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", |
| "InstanceId"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04251 " |
| "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04345 " |
| "VUID-InstanceId-InstanceId-04254 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RTBuiltIn3StageI32NotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", |
| "InstanceId"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Output"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04252 " |
| "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04346 " |
| "VUID-InstanceId-InstanceId-04255 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RTBuiltIn3StageI32NotIntScalar, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR", |
| "InstanceId"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04253 " |
| "VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04347 " |
| "VUID-InstanceId-InstanceId-04256 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| // PrimitiveId needs special negative testing because it has non-RT uses |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdRTNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine( |
| Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"), |
| Values("RayGenerationKHR", "MissKHR", "CallableKHR"), Values("Input"), |
| Values("%u32"), Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-PrimitiveId-PrimitiveId-04330"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "to be used only with Fragment, TessellationControl, " |
| "TessellationEvaluation, Geometry, MeshNV, MeshEXT, " |
| "IntersectionKHR, " |
| "AnyHitKHR, and ClosestHitKHR execution models")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdRTNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Output"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-PrimitiveId-PrimitiveId-04334"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Output storage class if execution model is ")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PrimitiveIdRTNotIntScalar, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-PrimitiveId-PrimitiveId-04337"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| // ObjectRayDirectionKHR and ObjectRayOriginKHR valid |
| // in IS, AH, CH shaders as input 32-bit float vec3 |
| INSTANTIATE_TEST_SUITE_P( |
| ObjectRayDirectionAndOriginSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Input"), Values("%f32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ObjectRayDirectionAndOriginNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"), |
| Values("Input"), Values("%f32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04299 " |
| "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04302 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ObjectRayDirectionAndOriginNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Output"), Values("%f32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04300 " |
| "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04303 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ObjectRayDirectionAndOriginNotFloatVec3, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine( |
| Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Input"), Values("%u32vec3", "%f32", "%f32vec2", "%f32vec4"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04301 " |
| "VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04304 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit float vector")))); |
| |
| // ObjectToWorldKHR and WorldToObjectKHR valid |
| // in IS, AH, CH shaders as input mat4x3 |
| INSTANTIATE_TEST_SUITE_P( |
| RTObjectMatrixSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectToWorldKHR", "WorldToObjectKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Input"), Values("%f32mat34"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RTObjectMatrixNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectToWorldKHR", "WorldToObjectKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"), |
| Values("Input"), Values("%f32mat34"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04305 " |
| "VUID-WorldToObjectKHR-WorldToObjectKHR-04434 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RTObjectMatrixNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectToWorldKHR", "WorldToObjectKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Output"), Values("%f32mat34"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04306 " |
| "VUID-WorldToObjectKHR-WorldToObjectKHR-04435 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RTObjectMatrixNotMat4x3, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("ObjectToWorldKHR", "WorldToObjectKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"), |
| Values("Input"), Values("%f32mat43", "%f32mat44", "%f32vec4"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04307 " |
| "VUID-WorldToObjectKHR-WorldToObjectKHR-04436 "), |
| Values(TestResult( |
| SPV_ERROR_INVALID_DATA, |
| "variable needs to be a matrix with " |
| "4 columns of 3-component vectors of 32-bit floats")))); |
| |
| // IncomingRayFlagsKHR is valid |
| // in IS, AH, CH, MS shaders as an input i32 scalar |
| INSTANTIATE_TEST_SUITE_P( |
| IncomingRayFlagsSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| IncomingRayFlagsNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "CallableKHR"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04348 " |
| "VUID-RayTminKHR-RayTminKHR-04351 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| IncomingRayFlagsNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Output"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04349 " |
| "VUID-RayTminKHR-RayTminKHR-04352 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| INSTANTIATE_TEST_SUITE_P( |
| IncomingRayFlagsNotIntScalar, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04350 " |
| "VUID-RayTminKHR-RayTminKHR-04353 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| // CullMaskKHR is valid |
| // in IS, AH, CH, MS shaders as an input i32 scalar |
| INSTANTIATE_TEST_SUITE_P( |
| CullMaskSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " |
| "\"SPV_KHR_ray_cull_mask\"\n"), |
| Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| CullMaskNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "CallableKHR"), |
| Values("Input"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " |
| "\"SPV_KHR_ray_cull_mask\"\n"), |
| Values("VUID-CullMaskKHR-CullMaskKHR-06735 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04348 " |
| "VUID-RayTminKHR-RayTminKHR-04351 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ICullMaskNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Output"), Values("%u32"), |
| Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " |
| "\"SPV_KHR_ray_cull_mask\"\n"), |
| Values("VUID-CullMaskKHR-CullMaskKHR-06736 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04349 " |
| "VUID-RayTminKHR-RayTminKHR-04352 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| INSTANTIATE_TEST_SUITE_P( |
| CullMaskNotIntScalar, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("CullMaskKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%f32", "%u32vec3"), |
| Values("OpCapability RayTracingKHR\nOpCapability RayCullMaskKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\nOpExtension " |
| "\"SPV_KHR_ray_cull_mask\"\n"), |
| Values("VUID-CullMaskKHR-CullMaskKHR-06737 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04350 " |
| "VUID-RayTminKHR-RayTminKHR-04353 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit int scalar", |
| "is not an int scalar")))); |
| |
| // RayTmaxKHR, RayTminKHR are all valid |
| // in IS, AH, CH, MS shaders as input f32 scalars |
| INSTANTIATE_TEST_SUITE_P( |
| RayTSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%f32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RayTNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "CallableKHR"), |
| Values("Input"), Values("%f32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04348 " |
| "VUID-RayTminKHR-RayTminKHR-04351 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RayTNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Output"), Values("%f32"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04349 " |
| "VUID-RayTminKHR-RayTminKHR-04352 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| INSTANTIATE_TEST_SUITE_P( |
| RayTNotFloatScalar, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%u32", "%f32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250 " |
| "VUID-RayTmaxKHR-RayTmaxKHR-04350 " |
| "VUID-RayTminKHR-RayTminKHR-04353 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "is not a float scalar")))); |
| |
| // WorldRayDirectionKHR and WorldRayOriginKHR are valid |
| // in IS, AH, CH, MS shaders as input 32-bit float vec3 |
| INSTANTIATE_TEST_SUITE_P( |
| WorldRayDirectionAndOriginSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%f32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| WorldRayDirectionAndOriginNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute", "RayGenerationKHR", "CallableKHR"), |
| Values("Input"), Values("%f32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04428 " |
| "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04431 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| WorldRayDirectionAndOriginNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), |
| Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Output"), Values("%f32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04429 " |
| "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04432 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| WorldRayDirectionAndOriginNotFloatVec3, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine( |
| Values(SPV_ENV_VULKAN_1_2), |
| Values("WorldRayDirectionKHR", "WorldRayOriginKHR"), |
| Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"), |
| Values("Input"), Values("%u32vec3", "%f32", "%f32vec2", "%f32vec4"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04430 " |
| "VUID-WorldRayOriginKHR-WorldRayOriginKHR-04433 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit float vector")))); |
| |
| // LaunchIdKHR and LaunchSizeKHR are valid |
| // in RG, IS, AH, CH, MS shaders as input 32-bit ivec3 |
| INSTANTIATE_TEST_SUITE_P( |
| LaunchRTSuccess, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), |
| Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR", |
| "IntersectionKHR", "MissKHR", "CallableKHR"), |
| Values("Input"), Values("%u32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr), |
| Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LaunchRTNotExecutionMode, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), |
| Values("Vertex", "Fragment", "TessellationControl", |
| "TessellationEvaluation", "Geometry", "Fragment", |
| "GLCompute"), |
| Values("Input"), Values("%u32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-LaunchIdKHR-LaunchIdKHR-04266 " |
| "VUID-LaunchSizeKHR-LaunchSizeKHR-04269 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "Vulkan spec does not allow BuiltIn", |
| "to be used with the execution model")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LaunchRTNotInput, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), |
| Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR", |
| "IntersectionKHR", "MissKHR", "CallableKHR"), |
| Values("Output"), Values("%u32vec3"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-LaunchIdKHR-LaunchIdKHR-04267 " |
| "VUID-LaunchSizeKHR-LaunchSizeKHR-04270 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows", |
| "used for variables with Input storage class")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| LaunchRTNotIntVec3, |
| ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult, |
| Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"), |
| Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR", |
| "IntersectionKHR", "MissKHR", "CallableKHR"), |
| Values("Input"), Values("%f32vec3", "%u32", "%u32vec2", "%u32vec4"), |
| Values("OpCapability RayTracingKHR\n"), |
| Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), |
| Values("VUID-LaunchIdKHR-LaunchIdKHR-04268 " |
| "VUID-LaunchSizeKHR-LaunchSizeKHR-04271 "), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 3-component 32-bit int vector")))); |
| |
| CodeGenerator GetArrayedVariableCodeGenerator(const char* const built_in, |
| const char* const execution_model, |
| const char* const storage_class, |
| const char* const data_type) { |
| CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator(); |
| |
| generator.before_types_ = "OpDecorate %built_in_var BuiltIn "; |
| generator.before_types_ += built_in; |
| generator.before_types_ += "\n"; |
| |
| std::ostringstream after_types; |
| after_types << "%built_in_array = OpTypeArray " << data_type << " %u32_3\n"; |
| if (InitializerRequired(storage_class)) { |
| after_types << "%built_in_array_null = OpConstantNull %built_in_array\n"; |
| } |
| |
| after_types << "%built_in_ptr = OpTypePointer " << storage_class |
| << " %built_in_array\n"; |
| after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class; |
| if (InitializerRequired(storage_class)) { |
| after_types << " %built_in_array_null"; |
| } |
| after_types << "\n"; |
| generator.after_types_ = after_types.str(); |
| |
| EntryPoint entry_point; |
| entry_point.name = "main"; |
| entry_point.execution_model = execution_model; |
| entry_point.interfaces = "%built_in_var"; |
| // Any kind of reference would do. |
| entry_point.body = R"( |
| %val = OpBitcast %u32 %built_in_var |
| )"; |
| |
| std::ostringstream execution_modes; |
| if (0 == std::strcmp(execution_model, "Fragment")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OriginUpperLeft\n"; |
| if (0 == std::strcmp(built_in, "FragDepth")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " DepthReplacing\n"; |
| } |
| } |
| if (0 == std::strcmp(execution_model, "Geometry")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " InputPoints\n"; |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " OutputPoints\n"; |
| } |
| if (0 == std::strcmp(execution_model, "GLCompute")) { |
| execution_modes << "OpExecutionMode %" << entry_point.name |
| << " LocalSize 1 1 1\n"; |
| } |
| entry_point.execution_modes = execution_modes.str(); |
| |
| generator.entry_points_.push_back(std::move(entry_point)); |
| |
| return generator; |
| } |
| |
| TEST_P(ValidateVulkanCombineBuiltInArrayedVariable, Variable) { |
| const char* const built_in = std::get<0>(GetParam()); |
| const char* const execution_model = std::get<1>(GetParam()); |
| const char* const storage_class = std::get<2>(GetParam()); |
| const char* const data_type = std::get<3>(GetParam()); |
| const char* const vuid = std::get<4>(GetParam()); |
| const TestResult& test_result = std::get<5>(GetParam()); |
| |
| CodeGenerator generator = GetArrayedVariableCodeGenerator( |
| built_in, execution_model, storage_class, data_type); |
| |
| CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0); |
| ASSERT_EQ(test_result.validation_result, |
| ValidateInstructions(SPV_ENV_VULKAN_1_0)); |
| if (test_result.error_str) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str)); |
| } |
| if (test_result.error_str2) { |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2)); |
| } |
| if (vuid) { |
| EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid)); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeArrayedF32TessControl, ValidateVulkanCombineBuiltInArrayedVariable, |
| Combine(Values("PointSize"), Values("TessellationControl"), Values("Input"), |
| Values("%f32"), Values(nullptr), Values(TestResult()))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeArrayedF64TessControl, ValidateVulkanCombineBuiltInArrayedVariable, |
| Combine(Values("PointSize"), Values("TessellationControl"), Values("Input"), |
| Values("%f64"), Values("VUID-PointSize-PointSize-04317"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "has bit width 64")))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| PointSizeArrayedF32Vertex, ValidateVulkanCombineBuiltInArrayedVariable, |
| Combine(Values("PointSize"), Values("Vertex"), Values("Output"), |
| Values("%f32"), Values("VUID-PointSize-PointSize-04317"), |
| Values(TestResult(SPV_ERROR_INVALID_DATA, |
| "needs to be a 32-bit float scalar", |
| "is not a float scalar")))); |
| |
| INSTANTIATE_TEST_SUITE_P(PositionArrayedF32Vec4TessControl, |
| ValidateVulkanCombineBuiltInArrayedVariable, |
| Combine(Values("Position"), |
