text: // Copyright (c) 2015-2016 The Khronos Group Inc.
  //
  // 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.
  
  // Validation tests for Logical Layout
  
  #include <sstream>
  #include <string>
  #include <tuple>
  #include <utility>
  #include <vector>
  
  #include "gmock/gmock.h"
  #include "source/assembly_grammar.h"
  #include "source/spirv_target_env.h"
  #include "spirv-tools/libspirv.h"
  #include "test/test_fixture.h"
  #include "test/unit_spirv.h"
  #include "test/val/val_fixtures.h"
  
  namespace spvtools {
  namespace val {
  namespace {
  
  using spvtest::ScopedContext;
  using testing::Combine;
  using testing::Eq;
  using testing::HasSubstr;
  using testing::Values;
  using testing::ValuesIn;
  
  // Parameter for validation test fixtures.  The first std::string is a
  // capability name that will begin the assembly under test, the second the
  // remainder assembly, and the std::vector at the end determines whether the
  // test expects success or failure.  See below for details and convenience
  // methods to access each one.
  //
  // The assembly to test is composed from a variable top line and a fixed
  // remainder.  The top line will be an OpCapability instruction, while the
  // remainder will be some assembly text that succeeds or fails to assemble
  // depending on which capability was chosen.  For instance, the following will
  // succeed:
  //
  // OpCapability Pipes ; implies Kernel
  // OpLifetimeStop %1 0 ; requires Kernel
  //
  // and the following will fail:
  //
  // OpCapability Kernel
  // %1 = OpTypeNamedBarrier ; requires NamedBarrier
  //
  // So how does the test parameter capture which capabilities should cause
  // success and which shouldn't?  The answer is in the last element: it's a
  // std::vector of capabilities that make the remainder assembly succeed.  So if
  // the first-line capability exists in that std::vector, success is expected;
  // otherwise, failure is expected in the tests.
  //
  // We will use testing::Combine() to vary the first line: when we combine
  // AllCapabilities() with a single remainder assembly, we generate enough test
  // cases to try the assembly with every possible capability that could be
  // declared. However, Combine() only produces tuples -- it cannot produce, say,
  // a struct.  Therefore, this type must be a tuple.
  using CapTestParameter =
      std::tuple<std::string, std::pair<std::string, std::vector<std::string>>>;
  
  const std::string& Capability(const CapTestParameter& p) {
    return std::get<0>(p);
  }
  const std::string& Remainder(const CapTestParameter& p) {
    return std::get<1>(p).first;
  }
  const std::vector<std::string>& MustSucceed(const CapTestParameter& p) {
    return std::get<1>(p).second;
  }
  
  // Creates assembly to test from p.
  std::string MakeAssembly(const CapTestParameter& p) {
    std::ostringstream ss;
    const std::string& capability = Capability(p);
    if (!capability.empty()) {
      ss << "OpCapability " << capability << "\n";
    }
    ss << Remainder(p);
    return ss.str();
  }
  
  // Expected validation result for p.
  spv_result_t ExpectedResult(const CapTestParameter& p) {
    const auto& caps = MustSucceed(p);
    auto found = find(begin(caps), end(caps), Capability(p));
    return (found == end(caps)) ? SPV_ERROR_INVALID_CAPABILITY : SPV_SUCCESS;
  }
  
  // Assembles using v1.0, unless the parameter's capability requires v1.1.
  using ValidateCapability = spvtest::ValidateBase<CapTestParameter>;
  
  // Always assembles using v1.1.
  using ValidateCapabilityV11 = spvtest::ValidateBase<CapTestParameter>;
  
  // Always assembles using Vulkan 1.0.
  // TODO(dneto): Refactor all these tests to scale better across environments.
  using ValidateCapabilityVulkan10 = spvtest::ValidateBase<CapTestParameter>;
  // Always assembles using OpenGL 4.0.
  using ValidateCapabilityOpenGL40 = spvtest::ValidateBase<CapTestParameter>;
  // Always assembles using Vulkan 1.1.
  using ValidateCapabilityVulkan11 = spvtest::ValidateBase<CapTestParameter>;
  // Always assembles using Vulkan 1.2.
  using ValidateCapabilityVulkan12 = spvtest::ValidateBase<CapTestParameter>;
  
  TEST_F(ValidateCapability, Default) {
    const char str[] = R"(
              OpCapability Kernel
              OpCapability Linkage
              OpCapability Matrix
              OpMemoryModel Logical OpenCL
  %f32      = OpTypeFloat 32
  %vec3     = OpTypeVector %f32 3
  %mat33    = OpTypeMatrix %vec3 3
  )";
  
    CompileSuccessfully(str);
    ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
  }
  
  // clang-format off
  const std::vector<std::string>& AllCapabilities() {
    static const auto r = new std::vector<std::string>{
      "",
      "Matrix",
      "Shader",
      "Geometry",
      "Tessellation",
      "Addresses",
      "Linkage",
      "Kernel",
      "Vector16",
      "Float16Buffer",
      "Float16",
      "Float64",
      "Int64",
      "Int64Atomics",
      "ImageBasic",
      "ImageReadWrite",
      "ImageMipmap",
      "Pipes",
      "Groups",
      "DeviceEnqueue",
      "LiteralSampler",
      "AtomicStorage",
      "Int16",
      "TessellationPointSize",
      "GeometryPointSize",
      "ImageGatherExtended",
      "StorageImageMultisample",
      "UniformBufferArrayDynamicIndexing",
      "SampledImageArrayDynamicIndexing",
      "StorageBufferArrayDynamicIndexing",
      "StorageImageArrayDynamicIndexing",
      "ClipDistance",
      "CullDistance",
      "ImageCubeArray",
      "SampleRateShading",
      "ImageRect",
      "SampledRect",
      "GenericPointer",
      "Int8",
      "InputAttachment",
      "SparseResidency",
      "MinLod",
      "Sampled1D",
      "Image1D",
      "SampledCubeArray",
      "SampledBuffer",
      "ImageBuffer",
      "ImageMSArray",
      "StorageImageExtendedFormats",
      "ImageQuery",
      "DerivativeControl",
      "InterpolationFunction",
      "TransformFeedback",
      "GeometryStreams",
      "StorageImageReadWithoutFormat",
      "StorageImageWriteWithoutFormat",
      "MultiViewport",
      "SubgroupDispatch",
      "NamedBarrier",
      "PipeStorage",
      "GroupNonUniform",
      "GroupNonUniformVote",
      "GroupNonUniformArithmetic",
      "GroupNonUniformBallot",
      "GroupNonUniformShuffle",
      "GroupNonUniformShuffleRelative",
      "GroupNonUniformClustered",
      "GroupNonUniformQuad",
      "DrawParameters",
      "StorageBuffer16BitAccess",
      "StorageUniformBufferBlock16",
      "UniformAndStorageBuffer16BitAccess",
      "StorageUniform16",
      "StoragePushConstant16",
      "StorageInputOutput16",
      "DeviceGroup",
      "MultiView",
      "VariablePointersStorageBuffer",
      "VariablePointers"};
    return *r;
  }
  
  const std::vector<std::string>& AllSpirV15Capabilities() {
    static const auto r = new std::vector<std::string>{
      "",
      "Matrix",
      "Shader",
      "Geometry",
      "Tessellation",
      "Addresses",
      "Linkage",
      "Kernel",
      "Vector16",
      "Float16Buffer",
      "Float16",
      "Float64",
      "Int64",
      "Int64Atomics",
      "ImageBasic",
      "ImageReadWrite",
      "ImageMipmap",
      "Pipes",
      "Groups",
      "DeviceEnqueue",
      "LiteralSampler",
      "AtomicStorage",
      "Int16",
      "TessellationPointSize",
      "GeometryPointSize",
      "ImageGatherExtended",
      "StorageImageMultisample",
      "UniformBufferArrayDynamicIndexing",
      "SampledImageArrayDynamicIndexing",
      "StorageBufferArrayDynamicIndexing",
      "StorageImageArrayDynamicIndexing",
      "ClipDistance",
      "CullDistance",
      "ImageCubeArray",
      "SampleRateShading",
      "ImageRect",
      "SampledRect",
      "GenericPointer",
      "Int8",
      "InputAttachment",
      "SparseResidency",
      "MinLod",
      "Sampled1D",
      "Image1D",
      "SampledCubeArray",
      "SampledBuffer",
      "ImageBuffer",
      "ImageMSArray",
      "StorageImageExtendedFormats",
      "ImageQuery",
      "DerivativeControl",
      "InterpolationFunction",
      "TransformFeedback",
      "GeometryStreams",
      "StorageImageReadWithoutFormat",
      "StorageImageWriteWithoutFormat",
      "MultiViewport",
      "SubgroupDispatch",
      "NamedBarrier",
      "PipeStorage",
      "GroupNonUniform",
      "GroupNonUniformVote",
      "GroupNonUniformArithmetic",
      "GroupNonUniformBallot",
      "GroupNonUniformShuffle",
      "GroupNonUniformShuffleRelative",
      "GroupNonUniformClustered",
      "GroupNonUniformQuad",
      "DrawParameters",
      "StorageBuffer16BitAccess",
      "StorageUniformBufferBlock16",
      "UniformAndStorageBuffer16BitAccess",
      "StorageUniform16",
      "StoragePushConstant16",
      "StorageInputOutput16",
      "DeviceGroup",
      "MultiView",
      "VariablePointersStorageBuffer",
      "VariablePointers",
      "DenormPreserve",
      "DenormFlushToZero",
      "SignedZeroInfNanPreserve",
      "RoundingModeRTE",
      "RoundingModeRTZ",
      // Omitted due to extra validation requirements on memory model.
      //"VulkanMemoryModel",
      //"VulkanMemoryModelDeviceScope",
      "StorageBuffer8BitAccess",
      "UniformAndStorageBuffer8BitAccess",
      "StoragePushConstant8",
      "ShaderViewportIndex",
      "ShaderLayer",
      "PhysicalStorageBufferAddresses",
      "RuntimeDescriptorArray",
      "UniformTexelBufferArrayDynamicIndexing",
      "StorageTexelBufferArrayDynamicIndexing",
      "UniformBufferArrayNonUniformIndexing",
      "SampledImageArrayNonUniformIndexing",
      "StorageBufferArrayNonUniformIndexing",
      "StorageImageArrayNonUniformIndexing",
      "InputAttachmentArrayNonUniformIndexing",
      "UniformTexelBufferArrayNonUniformIndexing",
      "StorageTexelBufferArrayNonUniformIndexing"};
    return *r;
  }
  
  const std::vector<std::string>& AllSpirV10Capabilities() {
    static const auto r = new std::vector<std::string>{
      "",
      "Matrix",
      "Shader",
      "Geometry",
      "Tessellation",
      "Addresses",
      "Linkage",
      "Kernel",
      "Vector16",
      "Float16Buffer",
      "Float16",
      "Float64",
      "Int64",
      "Int64Atomics",
      "ImageBasic",
      "ImageReadWrite",
      "ImageMipmap",
      "Pipes",
      "Groups",
      "DeviceEnqueue",
      "LiteralSampler",
      "AtomicStorage",
      "Int16",
      "TessellationPointSize",
      "GeometryPointSize",
      "ImageGatherExtended",
      "StorageImageMultisample",
      "UniformBufferArrayDynamicIndexing",
      "SampledImageArrayDynamicIndexing",
      "StorageBufferArrayDynamicIndexing",
      "StorageImageArrayDynamicIndexing",
      "ClipDistance",
      "CullDistance",
      "ImageCubeArray",
      "SampleRateShading",
      "ImageRect",
      "SampledRect",
      "GenericPointer",
      "Int8",
      "InputAttachment",
      "SparseResidency",
      "MinLod",
      "Sampled1D",
      "Image1D",
      "SampledCubeArray",
      "SampledBuffer",
      "ImageBuffer",
      "ImageMSArray",
      "StorageImageExtendedFormats",
      "ImageQuery",
      "DerivativeControl",
      "InterpolationFunction",
      "TransformFeedback",
      "GeometryStreams",
      "StorageImageReadWithoutFormat",
      "StorageImageWriteWithoutFormat",
      "MultiViewport"};
    return *r;
  }
  
  const std::vector<std::string>& AllVulkan10Capabilities() {
    static const auto r = new std::vector<std::string>{
      "",
      "Matrix",
      "Shader",
      "InputAttachment",
      "Sampled1D",
      "Image1D",
      "SampledBuffer",
      "ImageBuffer",
      "ImageQuery",
      "DerivativeControl",
      "Geometry",
      "Tessellation",
      "Float16",
      "Float64",
      "Int64",
      "Int64Atomics",
      "Int16",
      "TessellationPointSize",
      "GeometryPointSize",
      "ImageGatherExtended",
      "StorageImageMultisample",
      "UniformBufferArrayDynamicIndexing",
      "SampledImageArrayDynamicIndexing",
      "StorageBufferArrayDynamicIndexing",
      "StorageImageArrayDynamicIndexing",
      "ClipDistance",
      "CullDistance",
      "ImageCubeArray",
      "SampleRateShading",
      "Int8",
      "SparseResidency",
      "MinLod",
      "SampledCubeArray",
      "ImageMSArray",
      "StorageImageExtendedFormats",
      "InterpolationFunction",
      "StorageImageReadWithoutFormat",
      "StorageImageWriteWithoutFormat",
      "MultiViewport",
      "TransformFeedback",
      "GeometryStreams"};
    return *r;
  }
  
  const std::vector<std::string>& AllVulkan11Capabilities() {
    static const auto r = new std::vector<std::string>{
      "",
      "Matrix",
      "Shader",
      "InputAttachment",
      "Sampled1D",
      "Image1D",
      "SampledBuffer",
      "ImageBuffer",
      "ImageQuery",
      "DerivativeControl",
      "Geometry",
      "Tessellation",
      "Float16",
      "Float64",
      "Int64",
      "Int64Atomics",
      "Int16",
      "TessellationPointSize",
      "GeometryPointSize",
      "ImageGatherExtended",
      "StorageImageMultisample",
      "UniformBufferArrayDynamicIndexing",
      "SampledImageArrayDynamicIndexing",
      "StorageBufferArrayDynamicIndexing",
      "StorageImageArrayDynamicIndexing",
      "ClipDistance",
      "CullDistance",
      "ImageCubeArray",
      "SampleRateShading",
      "Int8",
      "SparseResidency",
      "MinLod",
      "SampledCubeArray",
      "ImageMSArray",
      "StorageImageExtendedFormats",
      "InterpolationFunction",
      "StorageImageReadWithoutFormat",
      "StorageImageWriteWithoutFormat",
      "MultiViewport",
      "GroupNonUniform",
      "GroupNonUniformVote",
      "GroupNonUniformArithmetic",
      "GroupNonUniformBallot",
      "GroupNonUniformShuffle",
      "GroupNonUniformShuffleRelative",
      "GroupNonUniformClustered",
      "GroupNonUniformQuad",
      "DrawParameters",
      "StorageBuffer16BitAccess",
      "StorageUniformBufferBlock16",
      "UniformAndStorageBuffer16BitAccess",
      "StorageUniform16",
      "StoragePushConstant16",
      "StorageInputOutput16",
      "DeviceGroup",
      "MultiView",
      "VariablePointersStorageBuffer",
      "VariablePointers",
      "TransformFeedback",
      "GeometryStreams"};
    return *r;
  }
  
  const std::vector<std::string>& AllVulkan12Capabilities() {
    static const auto r = new std::vector<std::string>{
      "",
      "Matrix",
      "Shader",
      "InputAttachment",
      "Sampled1D",
      "Image1D",
      "SampledBuffer",
      "ImageBuffer",
      "ImageQuery",
      "DerivativeControl",
      "Geometry",
      "Tessellation",
      "Float16",
      "Float64",
      "Int64",
      "Int64Atomics",
      "Int16",
      "TessellationPointSize",
      "GeometryPointSize",
      "ImageGatherExtended",
      "StorageImageMultisample",
      "UniformBufferArrayDynamicIndexing",
      "SampledImageArrayDynamicIndexing",
      "StorageBufferArrayDynamicIndexing",
      "StorageImageArrayDynamicIndexing",
      "ClipDistance",
      "CullDistance",
      "ImageCubeArray",
      "SampleRateShading",
      "Int8",
      "SparseResidency",
      "MinLod",
      "SampledCubeArray",
      "ImageMSArray",
      "StorageImageExtendedFormats",
      "InterpolationFunction",
      "StorageImageReadWithoutFormat",
      "StorageImageWriteWithoutFormat",
      "MultiViewport",
      "GroupNonUniform",
      "GroupNonUniformVote",
      "GroupNonUniformArithmetic",
      "GroupNonUniformBallot",
      "GroupNonUniformShuffle",
      "GroupNonUniformShuffleRelative",
      "GroupNonUniformClustered",
      "GroupNonUniformQuad",
      "DrawParameters",
      "StorageBuffer16BitAccess",
      "StorageUniformBufferBlock16",
      "UniformAndStorageBuffer16BitAccess",
      "StorageUniform16",
      "StoragePushConstant16",
      "StorageInputOutput16",
      "DeviceGroup",
      "MultiView",
      "VariablePointersStorageBuffer",
      "VariablePointers",
      "TransformFeedback",
      "GeometryStreams",
      "DenormPreserve",
      "DenormFlushToZero",
      "SignedZeroInfNanPreserve",
      "RoundingModeRTE",
      "RoundingModeRTZ",
      "VulkanMemoryModel",
      "VulkanMemoryModelDeviceScope",
      "StorageBuffer8BitAccess",
      "UniformAndStorageBuffer8BitAccess",
      "StoragePushConstant8",
      "ShaderViewportIndex",
      "ShaderLayer",
      "PhysicalStorageBufferAddresses",
      "RuntimeDescriptorArray",
      "UniformTexelBufferArrayDynamicIndexing",
      "StorageTexelBufferArrayDynamicIndexing",
      "UniformBufferArrayNonUniformIndexing",
      "SampledImageArrayNonUniformIndexing",
      "StorageBufferArrayNonUniformIndexing",
      "StorageImageArrayNonUniformIndexing",
      "InputAttachmentArrayNonUniformIndexing",
      "UniformTexelBufferArrayNonUniformIndexing",
      "StorageTexelBufferArrayNonUniformIndexing"};
    return *r;
  }
  
  const std::vector<std::string>& MatrixDependencies() {
    static const auto r = new std::vector<std::string>{
    "Matrix",
    "Shader",
    "Geometry",
    "Tessellation",
    "AtomicStorage",
    "TessellationPointSize",
    "GeometryPointSize",
    "ImageGatherExtended",
    "StorageImageMultisample",
    "UniformBufferArrayDynamicIndexing",
    "SampledImageArrayDynamicIndexing",
    "StorageBufferArrayDynamicIndexing",
    "StorageImageArrayDynamicIndexing",
    "ClipDistance",
    "CullDistance",
    "ImageCubeArray",
    "SampleRateShading",
    "ImageRect",
    "SampledRect",
    "InputAttachment",
    "SparseResidency",
    "MinLod",
    "SampledCubeArray",
    "ImageMSArray",
    "StorageImageExtendedFormats",
    "ImageQuery",
    "DerivativeControl",
    "InterpolationFunction",
    "TransformFeedback",
    "GeometryStreams",
    "StorageImageReadWithoutFormat",
    "StorageImageWriteWithoutFormat",
    "MultiViewport",
    "DrawParameters",
    "MultiView",
    "VariablePointersStorageBuffer",
    "VariablePointers"};
    return *r;
  }
  
  const std::vector<std::string>& ShaderDependencies() {
    static const auto r = new std::vector<std::string>{
    "Shader",
    "Geometry",
    "Tessellation",
    "AtomicStorage",
    "TessellationPointSize",
    "GeometryPointSize",
    "ImageGatherExtended",
    "StorageImageMultisample",
    "UniformBufferArrayDynamicIndexing",
    "SampledImageArrayDynamicIndexing",
    "StorageBufferArrayDynamicIndexing",
    "StorageImageArrayDynamicIndexing",
    "ClipDistance",
    "CullDistance",
    "ImageCubeArray",
    "SampleRateShading",
    "ImageRect",
    "SampledRect",
    "InputAttachment",
    "SparseResidency",
    "MinLod",
    "SampledCubeArray",
    "ImageMSArray",
    "StorageImageExtendedFormats",
    "ImageQuery",
    "DerivativeControl",
    "InterpolationFunction",
    "TransformFeedback",
    "GeometryStreams",
    "StorageImageReadWithoutFormat",
    "StorageImageWriteWithoutFormat",
    "MultiViewport",
    "DrawParameters",
    "MultiView",
    "VariablePointersStorageBuffer",
    "VariablePointers"};
    return *r;
  }
  
  const std::vector<std::string>& TessellationDependencies() {
    static const auto r = new std::vector<std::string>{
    "Tessellation",
    "TessellationPointSize"};
    return *r;
  }
  
  const std::vector<std::string>& GeometryDependencies() {
    static const auto r = new std::vector<std::string>{
    "Geometry",
    "GeometryPointSize",
    "GeometryStreams",
    "MultiViewport"};
    return *r;
  }
  
  const std::vector<std::string>& GeometryTessellationDependencies() {
    static const auto r = new std::vector<std::string>{
    "Tessellation",
    "TessellationPointSize",
    "Geometry",
    "GeometryPointSize",
    "GeometryStreams",
    "MultiViewport"};
    return *r;
  }
  
  // Returns the names of capabilities that directly depend on Kernel,
  // plus itself.
  const std::vector<std::string>& KernelDependencies() {
    static const auto r = new std::vector<std::string>{
    "Kernel",
    "Vector16",
    "Float16Buffer",
    "ImageBasic",
    "ImageReadWrite",
    "ImageMipmap",
    "Pipes",
    "DeviceEnqueue",
    "LiteralSampler",
    "SubgroupDispatch",
    "NamedBarrier",
    "PipeStorage"};
    return *r;
  }
  
  const std::vector<std::string>& KernelAndGroupNonUniformDependencies() {
    static const auto r = new std::vector<std::string>{
    "Kernel",
    "Vector16",
    "Float16Buffer",
    "ImageBasic",
    "ImageReadWrite",
    "ImageMipmap",
    "Pipes",
    "DeviceEnqueue",
    "LiteralSampler",
    "SubgroupDispatch",
    "NamedBarrier",
    "PipeStorage",
    "GroupNonUniform",
    "GroupNonUniformVote",
    "GroupNonUniformArithmetic",
    "GroupNonUniformBallot",
    "GroupNonUniformShuffle",
    "GroupNonUniformShuffleRelative",
    "GroupNonUniformClustered",
    "GroupNonUniformQuad"};
    return *r;
  }
  
  const std::vector<std::string>& AddressesDependencies() {
    static const auto r = new std::vector<std::string>{
    "Addresses",
    "GenericPointer"};
    return *r;
  }
  
  const std::vector<std::string>& Sampled1DDependencies() {
    static const auto r = new std::vector<std::string>{
    "Sampled1D",
    "Image1D"};
    return *r;
  }
  
  const std::vector<std::string>& SampledRectDependencies() {
    static const auto r = new std::vector<std::string>{
    "SampledRect",
    "ImageRect"};
    return *r;
  }
  
  const std::vector<std::string>& SampledBufferDependencies() {
    static const auto r = new std::vector<std::string>{
    "SampledBuffer",
    "ImageBuffer"};
    return *r;
  }
  
  const char kOpenCLMemoryModel[] = \
    " OpCapability Kernel"
    " OpMemoryModel Logical OpenCL ";
  
  const char kGLSL450MemoryModel[] = \
    " OpCapability Shader"
    " OpMemoryModel Logical GLSL450 ";
  
  const char kVoidFVoid[] = \
    " %void   = OpTypeVoid"
    " %void_f = OpTypeFunction %void"
    " %func   = OpFunction %void None %void_f"
    " %label  = OpLabel"
    "           OpReturn"
    "           OpFunctionEnd ";
  
  const char kVoidFVoid2[] = \
    " %void_f = OpTypeFunction %voidt"
    " %func   = OpFunction %voidt None %void_f"
    " %label  = OpLabel"
    "           OpReturn"
    "           OpFunctionEnd ";
  
  INSTANTIATE_TEST_SUITE_P(ExecutionModel, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint TessellationControl %func \"shader\"" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint TessellationEvaluation %func \"shader\"" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Geometry %func \"shader\"" +
            " OpExecutionMode %func InputPoints" +
            " OpExecutionMode %func OutputPoints" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Fragment %func \"shader\"" +
            " OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint GLCompute %func \"shader\"" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Kernel %func \"shader\"" +
            std::string(kVoidFVoid), KernelDependencies())
  )));
  
  INSTANTIATE_TEST_SUITE_P(AddressingAndMemoryModel, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(" OpCapability Shader"
            " OpMemoryModel Logical Simple"
            " OpEntryPoint Vertex %func \"shader\"" +
            std::string(kVoidFVoid),     AllCapabilities()),
  std::make_pair(" OpCapability Shader"
            " OpMemoryModel Logical GLSL450"
            " OpEntryPoint Vertex %func \"shader\"" +
            std::string(kVoidFVoid),    AllCapabilities()),
  std::make_pair(" OpCapability Kernel"
            " OpMemoryModel Logical OpenCL"
            " OpEntryPoint Kernel %func \"compute\"" +
            std::string(kVoidFVoid),     AllCapabilities()),
  std::make_pair(" OpCapability Shader"
            " OpMemoryModel Physical32 Simple"
            " OpEntryPoint Vertex %func \"shader\"" +
            std::string(kVoidFVoid),  AddressesDependencies()),
  std::make_pair(" OpCapability Shader"
            " OpMemoryModel Physical32 GLSL450"
            " OpEntryPoint Vertex %func \"shader\"" +
            std::string(kVoidFVoid), AddressesDependencies()),
  std::make_pair(" OpCapability Kernel"
            " OpMemoryModel Physical32 OpenCL"
            " OpEntryPoint Kernel %func \"compute\"" +
            std::string(kVoidFVoid),  AddressesDependencies()),
  std::make_pair(" OpCapability Shader"
            " OpMemoryModel Physical64 Simple"
            " OpEntryPoint Vertex %func \"shader\"" +
            std::string(kVoidFVoid),  AddressesDependencies()),
  std::make_pair(" OpCapability Shader"
            " OpMemoryModel Physical64 GLSL450"
            " OpEntryPoint Vertex %func \"shader\"" +
            std::string(kVoidFVoid), AddressesDependencies()),
  std::make_pair(" OpCapability Kernel"
            " OpMemoryModel Physical64 OpenCL"
            " OpEntryPoint Kernel %func \"compute\"" +
            std::string(kVoidFVoid),  AddressesDependencies())
  )));
  
  INSTANTIATE_TEST_SUITE_P(ExecutionMode, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func Invocations 42" +
            " OpExecutionMode %func InputPoints" +
            " OpExecutionMode %func OutputPoints" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func SpacingEqual" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func SpacingFractionalEven" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func SpacingFractionalOdd" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func VertexOrderCw" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func VertexOrderCcw" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func PixelCenterInteger" +
            " OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func OriginLowerLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func EarlyFragmentTests" +
            " OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func PointMode" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" "
            "OpExecutionMode %func Xfb" +
            std::string(kVoidFVoid), std::vector<std::string>{"TransformFeedback"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func DepthReplacing" +
            " OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func DepthGreater" +
            " OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func DepthLess" +
            " OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Fragment %func \"shader\" "
            "OpExecutionMode %func DepthUnchanged" +
            " OpExecutionMode %func OriginUpperLeft" +
            std::string(kVoidFVoid), ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"shader\" "
            "OpExecutionMode %func LocalSize 42 42 42" +
            std::string(kVoidFVoid), AllCapabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Kernel %func \"shader\" "
            "OpExecutionMode %func LocalSizeHint 42 42 42" +
            std::string(kVoidFVoid), KernelDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func InputPoints" +
            " OpExecutionMode %func OutputPoints" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func InputLines" +
            " OpExecutionMode %func OutputLineStrip" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func InputLinesAdjacency" +
            " OpExecutionMode %func OutputLineStrip" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func Triangles" +
            " OpExecutionMode %func OutputTriangleStrip" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func Triangles" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func InputTrianglesAdjacency" +
            " OpExecutionMode %func OutputTriangleStrip" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func Quads" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func Isolines" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func OutputVertices 42" +
            " OpExecutionMode %func OutputPoints" +
            " OpExecutionMode %func InputPoints" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint TessellationControl %func \"shader\" "
            "OpExecutionMode %func OutputVertices 42" +
            std::string(kVoidFVoid), TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func OutputPoints" +
            " OpExecutionMode %func InputPoints" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func OutputLineStrip" +
            " OpExecutionMode %func InputLines" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Geometry %func \"shader\" "
            "OpExecutionMode %func OutputTriangleStrip" +
            " OpExecutionMode %func Triangles" +
            std::string(kVoidFVoid), GeometryDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Kernel %func \"shader\" "
            "OpExecutionMode %func VecTypeHint 2" +
            std::string(kVoidFVoid), KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Kernel %func \"shader\" "
            "OpExecutionMode %func ContractionOff" +
            std::string(kVoidFVoid), KernelDependencies()))));
  
  // clang-format on
  
  INSTANTIATE_TEST_SUITE_P(
      ExecutionModeV11, ValidateCapabilityV11,
      Combine(ValuesIn(AllCapabilities()),
              Values(std::make_pair(std::string(kOpenCLMemoryModel) +
                                        "OpEntryPoint Kernel %func \"shader\" "
                                        "OpExecutionMode %func SubgroupSize 1" +
                                        std::string(kVoidFVoid),
                                    std::vector<std::string>{"SubgroupDispatch"}),
                     std::make_pair(
                         std::string(kOpenCLMemoryModel) +
                             "OpEntryPoint Kernel %func \"shader\" "
                             "OpExecutionMode %func SubgroupsPerWorkgroup 65535" +
                             std::string(kVoidFVoid),
                         std::vector<std::string>{"SubgroupDispatch"}))));
  // clang-format off
  
  INSTANTIATE_TEST_SUITE_P(StorageClass, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer UniformConstant %intt\n"
            " %var = OpVariable %ptrt UniformConstant\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Kernel %func \"compute\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer Input %intt"
            " %var = OpVariable %ptrt Input\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer Uniform %intt\n"
            " %var = OpVariable %ptrt Uniform\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer Output %intt\n"
            " %var = OpVariable %ptrt Output\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer Workgroup %intt\n"
            " %var = OpVariable %ptrt Workgroup\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer CrossWorkgroup %intt\n"
            " %var = OpVariable %ptrt CrossWorkgroup\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Kernel %func \"compute\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer Private %intt\n"
            " %var = OpVariable %ptrt Private\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            " OpEntryPoint Kernel %func \"compute\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer PushConstant %intt\n"
            " %var = OpVariable %ptrt PushConstant\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer AtomicCounter %intt\n"
            " %var = OpVariable %ptrt AtomicCounter\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"AtomicStorage"}),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\"" +
            " %intt = OpTypeInt 32 0\n"
            " %ptrt = OpTypePointer Image %intt\n"
            " %var = OpVariable %ptrt Image\n" + std::string(kVoidFVoid),
            AllCapabilities())
  )));
  
  INSTANTIATE_TEST_SUITE_P(Dim, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(" OpCapability ImageBasic" +
            std::string(kOpenCLMemoryModel) +
            std::string(" OpEntryPoint Kernel %func \"compute\"") +
            " %voidt = OpTypeVoid"
            " %imgt = OpTypeImage %voidt 1D 0 0 0 0 Unknown" + std::string(kVoidFVoid2),
            Sampled1DDependencies()),
  std::make_pair(" OpCapability ImageBasic" +
            std::string(kOpenCLMemoryModel) +
            std::string(" OpEntryPoint Kernel %func \"compute\"") +
            " %voidt = OpTypeVoid"
            " %imgt = OpTypeImage %voidt 2D 0 0 0 0 Unknown" + std::string(kVoidFVoid2),
            AllCapabilities()),
  std::make_pair(" OpCapability ImageBasic" +
            std::string(kOpenCLMemoryModel) +
            std::string(" OpEntryPoint Kernel %func \"compute\"") +
            " %voidt = OpTypeVoid"
            " %imgt = OpTypeImage %voidt 3D 0 0 0 0 Unknown" + std::string(kVoidFVoid2),
            AllCapabilities()),
  std::make_pair(" OpCapability ImageBasic" +
            std::string(kOpenCLMemoryModel) +
            std::string(" OpEntryPoint Kernel %func \"compute\"") +
            " %voidt = OpTypeVoid"
            " %imgt = OpTypeImage %voidt Cube 0 0 0 0 Unknown" + std::string(kVoidFVoid2),
            ShaderDependencies()),
  std::make_pair(" OpCapability ImageBasic" +
            std::string(kOpenCLMemoryModel) +
            std::string(" OpEntryPoint Kernel %func \"compute\"") +
            " %voidt = OpTypeVoid"
            " %imgt = OpTypeImage %voidt Rect 0 0 0 0 Unknown" + std::string(kVoidFVoid2),
            SampledRectDependencies()),
  std::make_pair(" OpCapability ImageBasic" +
            std::string(kOpenCLMemoryModel) +
            std::string(" OpEntryPoint Kernel %func \"compute\"") +
            " %voidt = OpTypeVoid"
            " %imgt = OpTypeImage %voidt Buffer 0 0 0 0 Unknown" + std::string(kVoidFVoid2),
            SampledBufferDependencies()),
  std::make_pair(" OpCapability ImageBasic" +
            std::string(kOpenCLMemoryModel) +
            std::string(" OpEntryPoint Kernel %func \"compute\"") +
            " %voidt = OpTypeVoid"
            " %imgt = OpTypeImage %voidt SubpassData 0 0 0 2 Unknown" + std::string(kVoidFVoid2),
            std::vector<std::string>{"InputAttachment"})
  )));
  
  // NOTE: All Sampler Address Modes require kernel capabilities but the
  // OpConstantSampler requires LiteralSampler which depends on Kernel
  INSTANTIATE_TEST_SUITE_P(SamplerAddressingMode, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\""
            " %samplert = OpTypeSampler"
            " %sampler = OpConstantSampler %samplert None 1 Nearest" +
            std::string(kVoidFVoid),
            std::vector<std::string>{"LiteralSampler"}),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\""
            " %samplert = OpTypeSampler"
            " %sampler = OpConstantSampler %samplert ClampToEdge 1 Nearest" +
            std::string(kVoidFVoid),
            std::vector<std::string>{"LiteralSampler"}),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\""
            " %samplert = OpTypeSampler"
            " %sampler = OpConstantSampler %samplert Clamp 1 Nearest" +
            std::string(kVoidFVoid),
            std::vector<std::string>{"LiteralSampler"}),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\""
            " %samplert = OpTypeSampler"
            " %sampler = OpConstantSampler %samplert Repeat 1 Nearest" +
            std::string(kVoidFVoid),
            std::vector<std::string>{"LiteralSampler"}),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            " OpEntryPoint Vertex %func \"shader\""
            " %samplert = OpTypeSampler"
            " %sampler = OpConstantSampler %samplert RepeatMirrored 1 Nearest" +
            std::string(kVoidFVoid),
            std::vector<std::string>{"LiteralSampler"})
  )));
  
  // TODO(umar): Sampler Filter Mode
  // TODO(umar): Image Format
  // TODO(umar): Image Channel Order
  // TODO(umar): Image Channel Data Type
  // TODO(umar): Image Operands
  // TODO(umar): FP Fast Math Mode
  // TODO(umar): FP Rounding Mode
  // TODO(umar): Linkage Type
  // TODO(umar): Access Qualifier
  // TODO(umar): Function Parameter Attribute
  
  INSTANTIATE_TEST_SUITE_P(Decoration, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt RelaxedPrecision\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            // Block applies to struct type.
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %block Block\n"
            "%intt = OpTypeInt 32 0\n"
            "%block = OpTypeStruct %intt\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            // BufferBlock applies to struct type.
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %block BufferBlock\n"
            "%intt = OpTypeInt 32 0\n"
            "%block = OpTypeStruct %intt\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt RowMajor\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            MatrixDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt ColMajor\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            MatrixDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt ArrayStride 1\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt MatrixStride 1\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            MatrixDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt GLSLShared\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt GLSLPacked\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpDecorate %intt CPacked\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt NoPerspective\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Flat\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Patch\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Centroid\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Sample\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"SampleRateShading"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Invariant\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Restrict\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Aliased\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Volatile\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpDecorate %intt Constant\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Coherent\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            // NonWritable must target something valid, such as a storage image.
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %var NonWritable "
            "%float = OpTypeFloat 32 "
            "%imstor = OpTypeImage %float 2D 0 0 0 2 Unknown "
            "%ptr = OpTypePointer UniformConstant %imstor "
            "%var = OpVariable %ptr UniformConstant "
            + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt NonReadable\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            // Uniform must target a non-void value.
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %int0 Uniform\n"
            "%intt = OpTypeInt 32 0\n" +
            "%int0 = OpConstantNull %intt"
            + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpDecorate %intt SaturatedConversion\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Stream 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"GeometryStreams"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpMemberDecorate %struct 0 Location 0\n"
            "%intt = OpTypeInt 32 0\n"
            "%struct = OpTypeStruct %intt\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %var Component 0\n"
            "%intt = OpTypeInt 32 0\n"
            "%ptr = OpTypePointer Input %intt\n"
            "%var = OpVariable %ptr Input\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Index 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Binding 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt DescriptorSet 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt Offset 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt XfbBuffer 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"TransformFeedback"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt XfbStride 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"TransformFeedback"}),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpDecorate %intt FuncParamAttr Zext\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpDecorate %intt FPFastMathMode Fast\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt LinkageAttributes \"other\" Import\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"Linkage"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt NoContraction\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n"
            "OpDecorate %intt InputAttachmentIndex 0\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"InputAttachment"}),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpDecorate %intt Alignment 4\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            KernelDependencies())
  )));
  
  // clang-format on
  INSTANTIATE_TEST_SUITE_P(
      DecorationSpecId, ValidateCapability,
      Combine(
          ValuesIn(AllSpirV10Capabilities()),
          Values(std::make_pair(std::string(kOpenCLMemoryModel) +
                                    "OpEntryPoint Vertex %func \"shader\" \n" +
                                    "OpDecorate %1 SpecId 1\n"
                                    "%intt = OpTypeInt 32 0\n"
                                    "%1 = OpSpecConstant %intt 0\n" +
                                    std::string(kVoidFVoid),
                                ShaderDependencies()))));
  
  INSTANTIATE_TEST_SUITE_P(
      DecorationV11, ValidateCapabilityV11,
      Combine(ValuesIn(AllCapabilities()),
              Values(std::make_pair(std::string(kOpenCLMemoryModel) +
                                        "OpEntryPoint Kernel %func \"compute\" \n"
                                        "OpDecorate %p MaxByteOffset 0 "
                                        "%i32 = OpTypeInt 32 0 "
                                        "%pi32 = OpTypePointer Workgroup %i32 "
                                        "%p = OpVariable %pi32 Workgroup " +
                                        std::string(kVoidFVoid),
                                    AddressesDependencies()),
                     // Trying to test OpDecorate here, but if this fails due to
                     // incorrect OpMemoryModel validation, that must also be
                     // fixed.
                     std::make_pair(
                         std::string("OpMemoryModel Logical OpenCL "
                                     "OpEntryPoint Kernel %func \"compute\" \n"
                                     "OpDecorate %1 SpecId 1 "
                                     "%intt = OpTypeInt 32 0 "
                                     "%1 = OpSpecConstant %intt 0") +
                             std::string(kVoidFVoid),
                         KernelDependencies()),
                     std::make_pair(
                         std::string("OpMemoryModel Logical Simple "
                                     "OpEntryPoint Vertex %func \"shader\" \n"
                                     "OpDecorate %1 SpecId 1 "
                                     "%intt = OpTypeInt 32 0 "
                                     "%1 = OpSpecConstant %intt 0") +
                             std::string(kVoidFVoid),
                         ShaderDependencies()))));
  // clang-format off
  
  INSTANTIATE_TEST_SUITE_P(BuiltIn, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn Position\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  // Just mentioning PointSize, ClipDistance, or CullDistance as a BuiltIn does
  // not trigger the requirement for the associated capability.
  // See https://github.com/KhronosGroup/SPIRV-Tools/issues/365
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn PointSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn ClipDistance\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn CullDistance\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn VertexId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn InstanceId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn PrimitiveId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            GeometryTessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn InvocationId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            GeometryTessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn Layer\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            GeometryDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn ViewportIndex\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"MultiViewport"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn TessLevelOuter\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn TessLevelInner\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn TessCoord\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn PatchVertices\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            TessellationDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn FragCoord\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn PointCoord\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn FrontFacing\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn SampleId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"SampleRateShading"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn SamplePosition\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            std::vector<std::string>{"SampleRateShading"}),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn SampleMask\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn FragDepth\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn HelperInvocation\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn VertexIndex\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn InstanceIndex\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn NumWorkgroups\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn WorkgroupSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn WorkgroupId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn LocalInvocationId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn GlobalInvocationId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn LocalInvocationIndex\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllCapabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn WorkDim\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn GlobalSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn EnqueuedWorkgroupSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn GlobalOffset\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn GlobalLinearId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn SubgroupSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelAndGroupNonUniformDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn SubgroupMaxSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn NumSubgroups\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelAndGroupNonUniformDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn NumEnqueuedSubgroups\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn SubgroupId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelAndGroupNonUniformDependencies()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn SubgroupLocalInvocationId\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            KernelAndGroupNonUniformDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn VertexIndex\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies()),
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "OpDecorate %int0 BuiltIn InstanceIndex\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            ShaderDependencies())
  )));
  
  // Ensure that mere mention of PointSize, ClipDistance, or CullDistance as
  // BuiltIns does not trigger the requirement for the associated
  // capability.
  // See https://github.com/KhronosGroup/SPIRV-Tools/issues/365
  INSTANTIATE_TEST_SUITE_P(BuiltIn, ValidateCapabilityVulkan10,
                          Combine(
                              // All capabilities to try.
                              ValuesIn(AllSpirV10Capabilities()),
                              Values(
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpMemberDecorate %block 0 BuiltIn PointSize\n"
            "%f32 = OpTypeFloat 32\n"
            "%block = OpTypeStruct %f32\n"
            "%intt = OpTypeInt 32 0\n" + std::string(kVoidFVoid),
            // Capabilities which should succeed.
            AllVulkan10Capabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpMemberDecorate %block 0 BuiltIn ClipDistance\n"
            "%f32 = OpTypeFloat 32\n"
            "%intt = OpTypeInt 32 0\n"
            "%intt_4 = OpConstant %intt 4\n"
            "%f32arr4 = OpTypeArray %f32 %intt_4\n"
            "%block = OpTypeStruct %f32arr4\n" + std::string(kVoidFVoid),
            AllVulkan10Capabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n"
            "OpMemberDecorate %block 0 BuiltIn CullDistance\n"
            "%f32 = OpTypeFloat 32\n"
            "%intt = OpTypeInt 32 0\n"
            "%intt_4 = OpConstant %intt 4\n"
            "%f32arr4 = OpTypeArray %f32 %intt_4\n"
            "%block = OpTypeStruct %f32arr4\n" + std::string(kVoidFVoid),
            AllVulkan10Capabilities())
  )));
  
  INSTANTIATE_TEST_SUITE_P(BuiltIn, ValidateCapabilityOpenGL40,
                          Combine(
                              // OpenGL 4.0 is based on SPIR-V 1.0
                              ValuesIn(AllSpirV10Capabilities()),
                              Values(
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn PointSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllSpirV10Capabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn ClipDistance\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllSpirV10Capabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn CullDistance\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllSpirV10Capabilities())
  )));
  
  INSTANTIATE_TEST_SUITE_P(Capabilities, ValidateCapabilityVulkan11,
                          Combine(
                              // All capabilities to try.
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn PointSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllVulkan11Capabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn CullDistance\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllVulkan11Capabilities())
  )));
  
  INSTANTIATE_TEST_SUITE_P(Capabilities, ValidateCapabilityVulkan12,
                          Combine(
                              // All capabilities to try.
                              ValuesIn(AllSpirV15Capabilities()),
                              Values(
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn PointSize\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllVulkan12Capabilities()),
  std::make_pair(std::string(kGLSL450MemoryModel) +
            "OpEntryPoint Vertex %func \"shader\" \n" +
            "OpDecorate %int0 BuiltIn CullDistance\n"
            "%intt = OpTypeInt 32 0\n"
            "%int0 = OpConstant %intt 0\n" + std::string(kVoidFVoid),
            AllVulkan12Capabilities())
  )));
  
  // TODO(umar): Selection Control
  // TODO(umar): Loop Control
  // TODO(umar): Function Control
  // TODO(umar): Memory Semantics
  // TODO(umar): Memory Access
  // TODO(umar): Scope
  // TODO(umar): Group Operation
  // TODO(umar): Kernel Enqueue Flags
  // TODO(umar): Kernel Profiling Flags
  
  INSTANTIATE_TEST_SUITE_P(MatrixOp, ValidateCapability,
                          Combine(
                              ValuesIn(AllCapabilities()),
                              Values(
  std::make_pair(std::string(kOpenCLMemoryModel) +
            "OpEntryPoint Kernel %func \"compute\" \n" +
            "%f32      = OpTypeFloat 32\n"
            "%vec3     = OpTypeVector %f32 3\n"
            "%mat33    = OpTypeMatrix %vec3 3\n" + std::string(kVoidFVoid),
            MatrixDependencies()))));
  // clang-format on
  
  #if 0
  // TODO(atgoo@github.com) The following test is not valid as it generates
  // invalid combinations of images, instructions and image operands.
  //
  // Creates assembly containing an OpImageFetch instruction using operands for
  // the image-operands part.  The assembly defines constants %fzero and %izero
  // that can be used for operands where IDs are required.  The assembly is valid,
  // apart from not declaring any capabilities required by the operands.
  string ImageOperandsTemplate(const std::string& operands) {
    ostringstream ss;
    // clang-format off
    ss << R"(
  OpCapability Kernel
  OpCapability Linkage
  OpMemoryModel Logical OpenCL
  
  %i32 = OpTypeInt 32 0
  %f32 = OpTypeFloat 32
  %v4i32 = OpTypeVector %i32 4
  %timg = OpTypeImage %i32 2D 0 0 0 0 Unknown
  %pimg = OpTypePointer UniformConstant %timg
  %tfun = OpTypeFunction %i32
  
  %vimg = OpVariable %pimg UniformConstant
  %izero = OpConstant %i32 0
  %fzero = OpConstant %f32 0.
  
  %main = OpFunction %i32 None %tfun
  %lbl = OpLabel
  %img = OpLoad %timg %vimg
  %r1 = OpImageFetch %v4i32 %img %izero )" << operands << R"(
  OpReturnValue %izero
  OpFunctionEnd
  )";
    // clang-format on
    return ss.str();
  }
  
  INSTANTIATE_TEST_SUITE_P(
      TwoImageOperandsMask, ValidateCapability,
      Combine(
          ValuesIn(AllCapabilities()),
          Values(std::make_pair(ImageOperandsTemplate("Bias|Lod %fzero %fzero"),
                           ShaderDependencies()),
                 std::make_pair(ImageOperandsTemplate("Lod|Offset %fzero %izero"),
                           std::vector<std::string>{"ImageGatherExtended"}),
                 std::make_pair(ImageOperandsTemplate("Sample|MinLod %izero %fzero"),
                           std::vector<std::string>{"MinLod"}),
                 std::make_pair(ImageOperandsTemplate("Lod|Sample %fzero %izero"),
                           AllCapabilities()))), );
  #endif
  
  // TODO(umar): Instruction capability checks
  
  spv_result_t spvCoreOperandTableNameLookup(spv_target_env env,
                                             const spv_operand_table table,
                                             const spv_operand_type_t type,
                                             const char* name,
                                             const size_t nameLength) {
    if (!table) return SPV_ERROR_INVALID_TABLE;
    if (!name) return SPV_ERROR_INVALID_POINTER;
  
    for (uint64_t typeIndex = 0; typeIndex < table->count; ++typeIndex) {
      const auto& group = table->types[typeIndex];
      if (type != group.type) continue;
      for (uint64_t index = 0; index < group.count; ++index) {
        const auto& entry = group.entries[index];
        // Check for min version only.
        if (spvVersionForTargetEnv(env) >= entry.minVersion &&
            nameLength == strlen(entry.name) &&
            !strncmp(entry.name, name, nameLength)) {
          return SPV_SUCCESS;
        }
      }
    }
  
    return SPV_ERROR_INVALID_LOOKUP;
  }
  
  // True if capability exists in core spec of env.
  bool Exists(const std::string& capability, spv_target_env env) {
    ScopedContext sc(env);
    return SPV_SUCCESS ==
           spvCoreOperandTableNameLookup(env, sc.context->operand_table,
                                         SPV_OPERAND_TYPE_CAPABILITY,
                                         capability.c_str(), capability.size());
  }
  
  TEST_P(ValidateCapability, Capability) {
    const std::string capability = Capability(GetParam());
    spv_target_env env = SPV_ENV_UNIVERSAL_1_0;
    if (!capability.empty()) {
      if (Exists(capability, SPV_ENV_UNIVERSAL_1_0))
        env = SPV_ENV_UNIVERSAL_1_0;
      else if (Exists(capability, SPV_ENV_UNIVERSAL_1_1))
        env = SPV_ENV_UNIVERSAL_1_1;
      else if (Exists(capability, SPV_ENV_UNIVERSAL_1_2))
        env = SPV_ENV_UNIVERSAL_1_2;
      else
        env = SPV_ENV_UNIVERSAL_1_3;
    }
    const std::string test_code = MakeAssembly(GetParam());
    CompileSuccessfully(test_code, env);
    ASSERT_EQ(ExpectedResult(GetParam()), ValidateInstructions(env))
        << "target env: " << spvTargetEnvDescription(env) << "\ntest code:\n"
        << test_code;
  }
  
  TEST_P(ValidateCapabilityV11, Capability) {
    const std::string capability = Capability(GetParam());
    if (Exists(capability, SPV_ENV_UNIVERSAL_1_1)) {
      const std::string test_code = MakeAssembly(GetParam());
      CompileSuccessfully(test_code, SPV_ENV_UNIVERSAL_1_1);
      ASSERT_EQ(ExpectedResult(GetParam()),
                ValidateInstructions(SPV_ENV_UNIVERSAL_1_1))
          << test_code;
    }
  }
  
  TEST_P(ValidateCapabilityVulkan10, Capability) {
    const std::string capability = Capability(GetParam());
    if (Exists(capability, SPV_ENV_VULKAN_1_0)) {
      const std::string test_code = MakeAssembly(GetParam());
      CompileSuccessfully(test_code, SPV_ENV_VULKAN_1_0);
      ASSERT_EQ(ExpectedResult(GetParam()),
                ValidateInstructions(SPV_ENV_VULKAN_1_0))
          << test_code;
    }
  }
  
  TEST_P(ValidateCapabilityVulkan11, Capability) {
    const std::string capability = Capability(GetParam());
    if (Exists(capability, SPV_ENV_VULKAN_1_1)) {
      const std::string test_code = MakeAssembly(GetParam());
      CompileSuccessfully(test_code, SPV_ENV_VULKAN_1_1);
      ASSERT_EQ(ExpectedResult(GetParam()),
                ValidateInstructions(SPV_ENV_VULKAN_1_1))
          << test_code;
    }
  }
  
  TEST_P(ValidateCapabilityVulkan12, Capability) {
    const std::string capability = Capability(GetParam());
    if (Exists(capability, SPV_ENV_VULKAN_1_2)) {
      const std::string test_code = MakeAssembly(GetParam());
      CompileSuccessfully(test_code, SPV_ENV_VULKAN_1_2);
      ASSERT_EQ(ExpectedResult(GetParam()),
                ValidateInstructions(SPV_ENV_VULKAN_1_2))
          << test_code;
    }
  }
  
  TEST_P(ValidateCapabilityOpenGL40, Capability) {
    const std::string capability = Capability(GetParam());
    if (Exists(capability, SPV_ENV_OPENGL_4_0)) {
      const std::string test_code = MakeAssembly(GetParam());
      CompileSuccessfully(test_code, SPV_ENV_OPENGL_4_0);
      ASSERT_EQ(ExpectedResult(GetParam()),
                ValidateInstructions(SPV_ENV_OPENGL_4_0))
          << test_code;
    }
  }
  
  TEST_F(ValidateCapability, SemanticsIdIsAnIdNotALiteral) {
    // From https://github.com/KhronosGroup/SPIRV-Tools/issues/248
    // The validator was interpreting the memory semantics ID number
    // as the value to be checked rather than an ID that references
    // another value to be checked.
    // In this case a raw ID of 64 was mistaken to mean a literal
    // semantic value of UniformMemory, which would require the Shader
    // capability.
    const char str[] = R"(
  OpCapability Kernel
  OpCapability Linkage
  OpMemoryModel Logical OpenCL
  
  ;  %i32 has ID 1
  %i32    = OpTypeInt 32 0
  %tf     = OpTypeFunction %i32
  %pi32   = OpTypePointer CrossWorkgroup %i32
  %var    = OpVariable %pi32 CrossWorkgroup
  %c      = OpConstant %i32 100
  %scope  = OpConstant %i32 1 ; Device scope
  
  ; Fake an instruction with 64 as the result id.
  ; !64 = OpConstantNull %i32
  !0x3002e !1 !64
  
  %f = OpFunction %i32 None %tf
  %l = OpLabel
  %result = OpAtomicIAdd %i32 %var %scope !64 %c
  OpReturnValue %result
  OpFunctionEnd
  )";
  
    CompileSuccessfully(str);
  
    // Since we are forcing usage of <id> 64, the "id bound" in the binary header
    // must be overwritten so that <id> 64 is considered within bound.
    // ID Bound is at index 3 of the binary. Set it to 65.
    OverwriteAssembledBinary(3, 65);
  
    ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
  }
  
  TEST_F(ValidateCapability, IntSignednessKernelGood) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Linkage
  OpMemoryModel Logical OpenCL
  %i32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
  }
  
  TEST_F(ValidateCapability, IntSignednessKernelBad) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Linkage
  OpMemoryModel Logical OpenCL
  %i32    = OpTypeInt 32 1
  )";
    CompileSuccessfully(spirv);
    EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions());
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("The Signedness in OpTypeInt must always be 0 when "
                          "Kernel capability is used."));
  }
  
  TEST_F(ValidateCapability, IntSignednessShaderGood) {
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability Linkage
  OpMemoryModel Logical GLSL450
  %u32    = OpTypeInt 32 0
  %i32    = OpTypeInt 32 1
  )";
    CompileSuccessfully(spirv);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
  }
  
  TEST_F(ValidateCapability, NonVulkan10Capability) {
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability Linkage
  OpMemoryModel Logical GLSL450
  %u32    = OpTypeInt 32 0
  %i32    = OpTypeInt 32 1
  )";
    CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_VULKAN_1_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Capability Linkage is not allowed by Vulkan 1.0"));
  }
  
  TEST_F(ValidateCapability, Vulkan10EnabledByExtension) {
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability DrawParameters
  OpExtension "SPV_KHR_shader_draw_parameters"
  OpMemoryModel Logical GLSL450
  OpEntryPoint Vertex %func "shader"
  OpMemberDecorate %block 0 BuiltIn PointSize
  %f32 = OpTypeFloat 32
  %block = OpTypeStruct %f32
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0));
  }
  
  TEST_F(ValidateCapability, Vulkan10NotEnabledByExtension) {
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability DrawParameters
  OpMemoryModel Logical GLSL450
  OpEntryPoint Vertex %func "shader"
  OpDecorate %intt BuiltIn PointSize
  %intt = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_VULKAN_1_0));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr("Capability DrawParameters is not allowed by Vulkan 1.0"));
  }
  
  TEST_F(ValidateCapability, NonOpenCL12FullCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Pipes
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_1_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_1_2));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr("Capability Pipes is not allowed by OpenCL 1.2 Full Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL12FullEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability ImageBasic
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_1_2);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_1_2));
  }
  
  TEST_F(ValidateCapability, OpenCL12FullNotEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_1_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_1_2));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr(
            "Capability Sampled1D is not allowed by OpenCL 1.2 Full Profile"));
  }
  
  TEST_F(ValidateCapability, NonOpenCL12EmbeddedCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Int64
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr(
            "Capability Int64 is not allowed by OpenCL 1.2 Embedded Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL12EmbeddedEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability ImageBasic
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2));
  }
  
  TEST_F(ValidateCapability, OpenCL12EmbeddedNotEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Capability Sampled1D is not allowed by OpenCL 1.2 "
                          "Embedded Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL12EmbeddedNoLongerEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Pipes
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_1_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_1_2));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Capability Pipes is not allowed by OpenCL 1.2 "
                          "Embedded Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL20FullCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Groups
  OpCapability Pipes
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_0));
  }
  
  TEST_F(ValidateCapability, NonOpenCL20FullCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Matrix
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_2_0));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr(
            "Capability Matrix is not allowed by OpenCL 2.0/2.1 Full Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL20FullEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability ImageBasic
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_0));
  }
  
  TEST_F(ValidateCapability, OpenCL20FullNotEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_2_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Capability Sampled1D is not allowed by OpenCL 2.0/2.1 "
                          "Full Profile"));
  }
  
  TEST_F(ValidateCapability, NonOpenCL20EmbeddedCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Int64
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Capability Int64 is not allowed by OpenCL 2.0/2.1 "
                          "Embedded Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL20EmbeddedEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability ImageBasic
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_0);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_0));
  }
  
  TEST_F(ValidateCapability, OpenCL20EmbeddedNotEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Capability Sampled1D is not allowed by OpenCL 2.0/2.1 "
                          "Embedded Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL22FullCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability PipeStorage
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_2));
  }
  
  TEST_F(ValidateCapability, NonOpenCL22FullCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Matrix
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_2_2));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr("Capability Matrix is not allowed by OpenCL 2.2 Full Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL22FullEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability ImageBasic
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_2_2));
  }
  
  TEST_F(ValidateCapability, OpenCL22FullNotEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_2_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_2_2));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr(
            "Capability Sampled1D is not allowed by OpenCL 2.2 Full Profile"));
  }
  
  TEST_F(ValidateCapability, NonOpenCL22EmbeddedCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Int64
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )";
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_2));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr(
            "Capability Int64 is not allowed by OpenCL 2.2 Embedded Profile"));
  }
  
  TEST_F(ValidateCapability, OpenCL22EmbeddedEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability ImageBasic
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_2);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_2));
  }
  
  TEST_F(ValidateCapability, OpenCL22EmbeddedNotEnabledByCapability) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability Linkage
  OpCapability Sampled1D
  OpMemoryModel Physical64 OpenCL
  %u32    = OpTypeInt 32 0
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_OPENCL_EMBEDDED_2_2);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_OPENCL_EMBEDDED_2_2));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Capability Sampled1D is not allowed by OpenCL 2.2 "
                          "Embedded Profile"));
  }
  
  // Three tests to check enablement of an enum (a decoration) which is not
  // in core, and is directly enabled by a capability, but not directly enabled
  // by an extension.  See https://github.com/KhronosGroup/SPIRV-Tools/issues/1596
  
  TEST_F(ValidateCapability, DecorationFromExtensionMissingEnabledByCapability) {
    // Decoration ViewportRelativeNV is enabled by ShaderViewportMaskNV, which in
    // turn is enabled by SPV_NV_viewport_array2.
    const std::string spirv = R"(
  OpCapability Shader
  OpMemoryModel Logical Simple
  OpDecorate %void ViewportRelativeNV
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_UNIVERSAL_1_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Operand 2 of Decorate requires one of these "
                          "capabilities: ShaderViewportMaskNV"));
  }
  
  TEST_F(ValidateCapability, CapabilityEnabledByMissingExtension) {
    // Capability ShaderViewportMaskNV is enabled by SPV_NV_viewport_array2.
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability ShaderViewportMaskNV
  OpMemoryModel Logical Simple
  )" + std::string(kVoidFVoid);
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0);
    EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION,
              ValidateInstructions(SPV_ENV_UNIVERSAL_1_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("operand ShaderViewportMaskNV(5255) requires one of "
                          "these extensions: SPV_NV_viewport_array2"));
  }
  
  TEST_F(ValidateCapability,
         DecorationEnabledByCapabilityEnabledByPresentExtension) {
    // Decoration ViewportRelativeNV is enabled by ShaderViewportMaskNV, which in
    // turn is enabled by SPV_NV_viewport_array2.
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability Linkage
  OpCapability ShaderViewportMaskNV
  OpExtension "SPV_NV_viewport_array2"
  OpMemoryModel Logical Simple
  OpDecorate %void ViewportRelativeNV
  %void = OpTypeVoid
  )";
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0))
        << getDiagnosticString();
  }
  
  // Three tests to check enablement of an instruction  which is not in core, and
  // is directly enabled by a capability, but not directly enabled by an
  // extension. See https://github.com/KhronosGroup/SPIRV-Tools/issues/1624
  // Instruction OpSubgroupShuffleINTEL is enabled by SubgroupShuffleINTEL, which
  // in turn is enabled by SPV_INTEL_subgroups.
  
  TEST_F(ValidateCapability, InstructionFromExtensionMissingEnabledByCapability) {
    // Decoration ViewportRelativeNV is enabled by ShaderViewportMaskNV, which in
    // turn is enabled by SPV_NV_viewport_array2.
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  ; OpCapability SubgroupShuffleINTEL
  OpExtension "SPV_INTEL_subgroups"
  OpMemoryModel Physical32 OpenCL
  OpEntryPoint Kernel %main "main"
  %void = OpTypeVoid
  %uint = OpTypeInt 32 0
  %voidfn = OpTypeFunction %void
  %zero = OpConstant %uint 0
  %main = OpFunction %void None %voidfn
  %entry = OpLabel
  %foo = OpSubgroupShuffleINTEL %uint %zero %zero
  OpReturn
  OpFunctionEnd
  )";
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0);
    EXPECT_EQ(SPV_ERROR_INVALID_CAPABILITY,
              ValidateInstructions(SPV_ENV_UNIVERSAL_1_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("Opcode SubgroupShuffleINTEL requires one of these "
                          "capabilities: SubgroupShuffleINTEL"));
  }
  
  TEST_F(ValidateCapability,
         InstructionEnablingCapabilityEnabledByMissingExtension) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability SubgroupShuffleINTEL
  ; OpExtension "SPV_INTEL_subgroups"
  OpMemoryModel Physical32 OpenCL
  OpEntryPoint Kernel %main "main"
  %void = OpTypeVoid
  %uint = OpTypeInt 32 0
  %voidfn = OpTypeFunction %void
  %zero = OpConstant %uint 0
  %main = OpFunction %void None %voidfn
  %entry = OpLabel
  %foo = OpSubgroupShuffleINTEL %uint %zero %zero
  OpReturn
  OpFunctionEnd
  )";
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0);
    EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION,
              ValidateInstructions(SPV_ENV_UNIVERSAL_1_0));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("operand SubgroupShuffleINTEL(5568) requires one of "
                          "these extensions: SPV_INTEL_subgroups"));
  }
  
  TEST_F(ValidateCapability,
         InstructionEnabledByCapabilityEnabledByPresentExtension) {
    const std::string spirv = R"(
  OpCapability Kernel
  OpCapability Addresses
  OpCapability SubgroupShuffleINTEL
  OpExtension "SPV_INTEL_subgroups"
  OpMemoryModel Physical32 OpenCL
  OpEntryPoint Kernel %main "main"
  %void = OpTypeVoid
  %uint = OpTypeInt 32 0
  %voidfn = OpTypeFunction %void
  %zero = OpConstant %uint 0
  %main = OpFunction %void None %voidfn
  %entry = OpLabel
  %foo = OpSubgroupShuffleINTEL %uint %zero %zero
  OpReturn
  OpFunctionEnd
  )";
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0))
        << getDiagnosticString();
  }
  
  TEST_F(ValidateCapability, VulkanMemoryModelWithVulkanKHR) {
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability VulkanMemoryModelKHR
  OpCapability Linkage
  OpExtension "SPV_KHR_vulkan_memory_model"
  OpMemoryModel Logical VulkanKHR
  )";
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3))
        << getDiagnosticString();
  }
  
  TEST_F(ValidateCapability, VulkanMemoryModelWithGLSL450) {
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability VulkanMemoryModelKHR
  OpCapability Linkage
  OpExtension "SPV_KHR_vulkan_memory_model"
  OpMemoryModel Logical GLSL450
  )";
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
    EXPECT_EQ(SPV_ERROR_INVALID_DATA,
              ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("VulkanMemoryModelKHR capability must only be "
                          "specified if the VulkanKHR memory model is used"));
  }
  
  // In the grammar, SubgroupEqMask and SubgroupMaskKHR have different enabling
  // lists of extensions.
  TEST_F(ValidateCapability, SubgroupEqMaskEnabledByExtension) {
    const std::string spirv = R"(
  OpCapability Shader
  OpCapability SubgroupBallotKHR
  OpExtension "SPV_KHR_shader_ballot"
  OpMemoryModel Logical Simple
  OpEntryPoint GLCompute %main "main"
  OpDecorate %var BuiltIn SubgroupEqMask
  %void = OpTypeVoid
  %uint = OpTypeInt 32 0
  %ptr_uint = OpTypePointer Private %uint
  %var = OpVariable %ptr_uint Private
  %fn = OpTypeFunction %void
  %main = OpFunction %void None %fn
  %entry = OpLabel
  %val = OpLoad %uint %var
  OpReturn
  OpFunctionEnd
  )";
  
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_0);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_0))
        << getDiagnosticString();
  }
  
  // Test that extensions incorporated into SPIR-V 1.5 no longer require
  // the associated OpExtension instruction.  Test one capability per extension.
  
  struct CapabilityExtensionVersionCase {
    std::string capability;
    std::string capability_new_name;
    std::string extension;
    spv_target_env last_version_requiring_extension;
    spv_target_env first_version_in_core;
  };
  
  using ValidateCapabilityExtensionVersionTest =
      spvtest::ValidateBase<CapabilityExtensionVersionCase>;
  
  // Returns a minimal shader module with the given capability instruction.
  std::string MinimalShaderModuleWithCapability(std::string cap) {
    std::string mem_model =
        (cap.find("VulkanMemory") == 0) ? "VulkanKHR" : "GLSL450";
    std::string extra_cap = (cap.find("VulkanMemoryModelDeviceScope") == 0)
                                ? "\nOpCapability VulkanMemoryModelKHR\n"
                                : "";
    return std::string("OpCapability ") + cap + extra_cap + R"(
  OpCapability Shader
  OpMemoryModel Logical )" + mem_model + R"(
  OpEntryPoint Vertex %main "main"
  %void = OpTypeVoid
  %void_fn = OpTypeFunction %void
  %main = OpFunction %void None %void_fn
  %entry = OpLabel
  OpReturn
  OpFunctionEnd
  )";
  }
  
  TEST_P(ValidateCapabilityExtensionVersionTest, FailsInOlderSpirvVersion) {
    const auto spirv = MinimalShaderModuleWithCapability(GetParam().capability);
    CompileSuccessfully(spirv, GetParam().last_version_requiring_extension);
    EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION,
              ValidateInstructions(GetParam().last_version_requiring_extension));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr(std::string("1st operand of Capability: operand ") +
                          GetParam().capability_new_name))
        << spirv << "\n";
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr(std::string("requires one of these extensions: ") +
                          GetParam().extension));
  }
  
  TEST_P(ValidateCapabilityExtensionVersionTest,
         SucceedsInNewerSpirvVersionWithOldName) {
    const auto spirv = MinimalShaderModuleWithCapability(GetParam().capability);
    CompileSuccessfully(spirv, GetParam().first_version_in_core);
    EXPECT_EQ(SPV_SUCCESS,
              ValidateInstructions(GetParam().first_version_in_core));
    EXPECT_THAT(getDiagnosticString(), Eq("")) << spirv << "\n";
  }
  
  TEST_P(ValidateCapabilityExtensionVersionTest,
         SucceedsInNewerSpirvVersionWithNewName) {
    const auto spirv =
        MinimalShaderModuleWithCapability(GetParam().capability_new_name);
    CompileSuccessfully(spirv, GetParam().first_version_in_core);
    EXPECT_EQ(SPV_SUCCESS,
              ValidateInstructions(GetParam().first_version_in_core));
    EXPECT_THAT(getDiagnosticString(), Eq("")) << spirv << "\n";
  }
  
  std::vector<CapabilityExtensionVersionCase> CapVersionCases1_5() {
  #define IN15NOSUFFIX(C, E) \
    { C, C, E, SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5 }
  #define IN15(C, C_WITHOUT_SUFFIX, E) \
    { C, C_WITHOUT_SUFFIX, E, SPV_ENV_UNIVERSAL_1_4, SPV_ENV_UNIVERSAL_1_5 }
    return std::vector<CapabilityExtensionVersionCase>{
        // SPV_KHR_8bit_storage
        IN15NOSUFFIX("StorageBuffer8BitAccess", "SPV_KHR_8bit_storage"),
        IN15NOSUFFIX("UniformAndStorageBuffer8BitAccess", "SPV_KHR_8bit_storage"),
        IN15NOSUFFIX("StoragePushConstant8", "SPV_KHR_8bit_storage"),
        // SPV_EXT_descriptor_indexing
        IN15("ShaderNonUniformEXT", "ShaderNonUniform",
             "SPV_EXT_descriptor_indexing"),
        IN15("RuntimeDescriptorArrayEXT", "RuntimeDescriptorArray",
             "SPV_EXT_descriptor_indexing"),
        IN15("InputAttachmentArrayDynamicIndexingEXT",
             "InputAttachmentArrayDynamicIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("UniformTexelBufferArrayDynamicIndexingEXT",
             "UniformTexelBufferArrayDynamicIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("StorageTexelBufferArrayDynamicIndexingEXT",
             "StorageTexelBufferArrayDynamicIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("UniformBufferArrayNonUniformIndexingEXT",
             "UniformBufferArrayNonUniformIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("SampledImageArrayNonUniformIndexingEXT",
             "SampledImageArrayNonUniformIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("StorageBufferArrayNonUniformIndexingEXT",
             "StorageBufferArrayNonUniformIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("StorageImageArrayNonUniformIndexingEXT",
             "StorageImageArrayNonUniformIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("InputAttachmentArrayNonUniformIndexingEXT",
             "InputAttachmentArrayNonUniformIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("UniformTexelBufferArrayNonUniformIndexingEXT",
             "UniformTexelBufferArrayNonUniformIndexing",
             "SPV_EXT_descriptor_indexing"),
        IN15("StorageTexelBufferArrayNonUniformIndexingEXT",
             "StorageTexelBufferArrayNonUniformIndexing",
             "SPV_EXT_descriptor_indexing"),
        // SPV_EXT_physical_storage_buffer
        IN15("PhysicalStorageBufferAddressesEXT",
             "PhysicalStorageBufferAddresses", "SPV_EXT_physical_storage_buffer"),
        // SPV_KHR_vulkan_memory_model
        IN15("VulkanMemoryModelKHR", "VulkanMemoryModel",
             "SPV_KHR_vulkan_memory_model"),
        IN15("VulkanMemoryModelDeviceScopeKHR", "VulkanMemoryModelDeviceScope",
             "SPV_KHR_vulkan_memory_model"),
    };
  #undef IN15
  }
  
  INSTANTIATE_TEST_SUITE_P(NewInSpirv1_5, ValidateCapabilityExtensionVersionTest,
                           ValuesIn(CapVersionCases1_5()));
  
  TEST_P(ValidateCapability,
         CapShaderViewportIndexLayerFailsInOlderSpirvVersion) {
    const auto spirv =
        MinimalShaderModuleWithCapability("ShaderViewportIndexLayerEXT");
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_4);
    EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION,
              ValidateInstructions(SPV_ENV_UNIVERSAL_1_4));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr(
            "1st operand of Capability: operand ShaderViewportIndexLayerEXT"));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("requires one of these extensions: "
                          "SPV_EXT_shader_viewport_index_layer"));
  }
  
  TEST_P(ValidateCapability, CapShaderViewportIndexLayerFailsInNewSpirvVersion) {
    const auto spirv =
        MinimalShaderModuleWithCapability("ShaderViewportIndexLayerEXT");
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5);
    EXPECT_EQ(SPV_ERROR_MISSING_EXTENSION,
              ValidateInstructions(SPV_ENV_UNIVERSAL_1_5));
    EXPECT_THAT(
        getDiagnosticString(),
        HasSubstr(
            "1st operand of Capability: operand ShaderViewportIndexLayerEXT"));
    EXPECT_THAT(getDiagnosticString(),
                HasSubstr("requires one of these extensions: "
                          "SPV_EXT_shader_viewport_index_layer"));
  }
  
  TEST_F(ValidateCapability, CapShaderViewportIndexSucceedsInNewSpirvVersion) {
    const auto spirv = MinimalShaderModuleWithCapability("ShaderViewportIndex");
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5));
    EXPECT_THAT(getDiagnosticString(), Eq(""));
  }
  
  TEST_F(ValidateCapability, CapShaderLayerSucceedsInNewSpirvVersion) {
    const auto spirv = MinimalShaderModuleWithCapability("ShaderLayer");
    CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_5);
    EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_5));
    EXPECT_THAT(getDiagnosticString(), Eq(""));
  }
  
  }  // namespace
  }  // namespace val
  }  // namespace spvtools
  