Home | History | Annotate | Download | only in test
      1 // Copyright (c) 2017 Google Inc.
      2 //
      3 // Licensed under the Apache License, Version 2.0 (the "License");
      4 // you may not use this file except in compliance with the License.
      5 // You may obtain a copy of the License at
      6 //
      7 //     http://www.apache.org/licenses/LICENSE-2.0
      8 //
      9 // Unless required by applicable law or agreed to in writing, software
     10 // distributed under the License is distributed on an "AS IS" BASIS,
     11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     12 // See the License for the specific language governing permissions and
     13 // limitations under the License.
     14 
     15 // Tests for OpExtension validator rules.
     16 
     17 #include <string>
     18 #include <utility>
     19 #include <vector>
     20 
     21 #include "gtest/gtest.h"
     22 #include "source/enum_string_mapping.h"
     23 #include "source/extensions.h"
     24 
     25 namespace spvtools {
     26 namespace {
     27 
     28 using ::testing::Values;
     29 using ::testing::ValuesIn;
     30 
     31 using ExtensionTest =
     32     ::testing::TestWithParam<std::pair<Extension, std::string>>;
     33 using UnknownExtensionTest = ::testing::TestWithParam<std::string>;
     34 using CapabilityTest =
     35     ::testing::TestWithParam<std::pair<SpvCapability, std::string>>;
     36 
     37 TEST_P(ExtensionTest, TestExtensionFromString) {
     38   const std::pair<Extension, std::string>& param = GetParam();
     39   const Extension extension = param.first;
     40   const std::string extension_str = param.second;
     41   Extension result_extension;
     42   ASSERT_TRUE(GetExtensionFromString(extension_str.c_str(), &result_extension));
     43   EXPECT_EQ(extension, result_extension);
     44 }
     45 
     46 TEST_P(ExtensionTest, TestExtensionToString) {
     47   const std::pair<Extension, std::string>& param = GetParam();
     48   const Extension extension = param.first;
     49   const std::string extension_str = param.second;
     50   const std::string result_str = ExtensionToString(extension);
     51   EXPECT_EQ(extension_str, result_str);
     52 }
     53 
     54 TEST_P(UnknownExtensionTest, TestExtensionFromStringFails) {
     55   Extension result_extension;
     56   ASSERT_FALSE(GetExtensionFromString(GetParam().c_str(), &result_extension));
     57 }
     58 
     59 TEST_P(CapabilityTest, TestCapabilityToString) {
     60   const std::pair<SpvCapability, std::string>& param = GetParam();
     61   const SpvCapability capability = param.first;
     62   const std::string capability_str = param.second;
     63   const std::string result_str = CapabilityToString(capability);
     64   EXPECT_EQ(capability_str, result_str);
     65 }
     66 
     67 INSTANTIATE_TEST_CASE_P(
     68     AllExtensions, ExtensionTest,
     69     ValuesIn(std::vector<std::pair<Extension, std::string>>({
     70         {Extension::kSPV_KHR_16bit_storage, "SPV_KHR_16bit_storage"},
     71         {Extension::kSPV_KHR_device_group, "SPV_KHR_device_group"},
     72         {Extension::kSPV_KHR_multiview, "SPV_KHR_multiview"},
     73         {Extension::kSPV_KHR_shader_ballot, "SPV_KHR_shader_ballot"},
     74         {Extension::kSPV_KHR_shader_draw_parameters,
     75          "SPV_KHR_shader_draw_parameters"},
     76         {Extension::kSPV_KHR_subgroup_vote, "SPV_KHR_subgroup_vote"},
     77         {Extension::kSPV_NVX_multiview_per_view_attributes,
     78          "SPV_NVX_multiview_per_view_attributes"},
     79         {Extension::kSPV_NV_geometry_shader_passthrough,
     80          "SPV_NV_geometry_shader_passthrough"},
     81         {Extension::kSPV_NV_sample_mask_override_coverage,
     82          "SPV_NV_sample_mask_override_coverage"},
     83         {Extension::kSPV_NV_stereo_view_rendering,
     84          "SPV_NV_stereo_view_rendering"},
     85         {Extension::kSPV_NV_viewport_array2, "SPV_NV_viewport_array2"},
     86         {Extension::kSPV_GOOGLE_decorate_string, "SPV_GOOGLE_decorate_string"},
     87         {Extension::kSPV_GOOGLE_hlsl_functionality1,
     88          "SPV_GOOGLE_hlsl_functionality1"},
     89         {Extension::kSPV_KHR_8bit_storage, "SPV_KHR_8bit_storage"},
     90     })));
     91 
     92 INSTANTIATE_TEST_CASE_P(UnknownExtensions, UnknownExtensionTest,
     93                         Values("", "SPV_KHR_", "SPV_KHR_device_group_ERROR",
     94                                /*alphabetically before all extensions*/ "A",
     95                                /*alphabetically after all extensions*/ "Z",
     96                                "SPV_ERROR_random_string_hfsdklhlktherh"));
     97 
     98 INSTANTIATE_TEST_CASE_P(
     99     AllCapabilities, CapabilityTest,
    100     ValuesIn(std::vector<std::pair<SpvCapability, std::string>>(
    101         {{SpvCapabilityMatrix, "Matrix"},
    102          {SpvCapabilityShader, "Shader"},
    103          {SpvCapabilityGeometry, "Geometry"},
    104          {SpvCapabilityTessellation, "Tessellation"},
    105          {SpvCapabilityAddresses, "Addresses"},
    106          {SpvCapabilityLinkage, "Linkage"},
    107          {SpvCapabilityKernel, "Kernel"},
    108          {SpvCapabilityVector16, "Vector16"},
    109          {SpvCapabilityFloat16Buffer, "Float16Buffer"},
    110          {SpvCapabilityFloat16, "Float16"},
    111          {SpvCapabilityFloat64, "Float64"},
    112          {SpvCapabilityInt64, "Int64"},
    113          {SpvCapabilityInt64Atomics, "Int64Atomics"},
    114          {SpvCapabilityImageBasic, "ImageBasic"},
    115          {SpvCapabilityImageReadWrite, "ImageReadWrite"},
    116          {SpvCapabilityImageMipmap, "ImageMipmap"},
    117          {SpvCapabilityPipes, "Pipes"},
    118          {SpvCapabilityGroups, "Groups"},
    119          {SpvCapabilityDeviceEnqueue, "DeviceEnqueue"},
    120          {SpvCapabilityLiteralSampler, "LiteralSampler"},
    121          {SpvCapabilityAtomicStorage, "AtomicStorage"},
    122          {SpvCapabilityInt16, "Int16"},
    123          {SpvCapabilityTessellationPointSize, "TessellationPointSize"},
    124          {SpvCapabilityGeometryPointSize, "GeometryPointSize"},
    125          {SpvCapabilityImageGatherExtended, "ImageGatherExtended"},
    126          {SpvCapabilityStorageImageMultisample, "StorageImageMultisample"},
    127          {SpvCapabilityUniformBufferArrayDynamicIndexing,
    128           "UniformBufferArrayDynamicIndexing"},
    129          {SpvCapabilitySampledImageArrayDynamicIndexing,
    130           "SampledImageArrayDynamicIndexing"},
    131          {SpvCapabilityStorageBufferArrayDynamicIndexing,
    132           "StorageBufferArrayDynamicIndexing"},
    133          {SpvCapabilityStorageImageArrayDynamicIndexing,
    134           "StorageImageArrayDynamicIndexing"},
    135          {SpvCapabilityClipDistance, "ClipDistance"},
    136          {SpvCapabilityCullDistance, "CullDistance"},
    137          {SpvCapabilityImageCubeArray, "ImageCubeArray"},
    138          {SpvCapabilitySampleRateShading, "SampleRateShading"},
    139          {SpvCapabilityImageRect, "ImageRect"},
    140          {SpvCapabilitySampledRect, "SampledRect"},
    141          {SpvCapabilityGenericPointer, "GenericPointer"},
    142          {SpvCapabilityInt8, "Int8"},
    143          {SpvCapabilityInputAttachment, "InputAttachment"},
    144          {SpvCapabilitySparseResidency, "SparseResidency"},
    145          {SpvCapabilityMinLod, "MinLod"},
    146          {SpvCapabilitySampled1D, "Sampled1D"},
    147          {SpvCapabilityImage1D, "Image1D"},
    148          {SpvCapabilitySampledCubeArray, "SampledCubeArray"},
    149          {SpvCapabilitySampledBuffer, "SampledBuffer"},
    150          {SpvCapabilityImageBuffer, "ImageBuffer"},
    151          {SpvCapabilityImageMSArray, "ImageMSArray"},
    152          {SpvCapabilityStorageImageExtendedFormats,
    153           "StorageImageExtendedFormats"},
    154          {SpvCapabilityImageQuery, "ImageQuery"},
    155          {SpvCapabilityDerivativeControl, "DerivativeControl"},
    156          {SpvCapabilityInterpolationFunction, "InterpolationFunction"},
    157          {SpvCapabilityTransformFeedback, "TransformFeedback"},
    158          {SpvCapabilityGeometryStreams, "GeometryStreams"},
    159          {SpvCapabilityStorageImageReadWithoutFormat,
    160           "StorageImageReadWithoutFormat"},
    161          {SpvCapabilityStorageImageWriteWithoutFormat,
    162           "StorageImageWriteWithoutFormat"},
    163          {SpvCapabilityMultiViewport, "MultiViewport"},
    164          {SpvCapabilitySubgroupDispatch, "SubgroupDispatch"},
    165          {SpvCapabilityNamedBarrier, "NamedBarrier"},
    166          {SpvCapabilityPipeStorage, "PipeStorage"},
    167          {SpvCapabilitySubgroupBallotKHR, "SubgroupBallotKHR"},
    168          {SpvCapabilityDrawParameters, "DrawParameters"},
    169          {SpvCapabilitySubgroupVoteKHR, "SubgroupVoteKHR"},
    170          {SpvCapabilityStorageBuffer16BitAccess, "StorageBuffer16BitAccess"},
    171          {SpvCapabilityStorageUniformBufferBlock16,
    172           "StorageBuffer16BitAccess"},  // Preferred name
    173          {SpvCapabilityUniformAndStorageBuffer16BitAccess,
    174           "UniformAndStorageBuffer16BitAccess"},
    175          {SpvCapabilityStorageUniform16,
    176           "UniformAndStorageBuffer16BitAccess"},  // Preferred name
    177          {SpvCapabilityStoragePushConstant16, "StoragePushConstant16"},
    178          {SpvCapabilityStorageInputOutput16, "StorageInputOutput16"},
    179          {SpvCapabilityDeviceGroup, "DeviceGroup"},
    180          {SpvCapabilityMultiView, "MultiView"},
    181          {SpvCapabilitySampleMaskOverrideCoverageNV,
    182           "SampleMaskOverrideCoverageNV"},
    183          {SpvCapabilityGeometryShaderPassthroughNV,
    184           "GeometryShaderPassthroughNV"},
    185          // The next two are different names for the same token.
    186          {SpvCapabilityShaderViewportIndexLayerNV,
    187           "ShaderViewportIndexLayerEXT"},
    188          {SpvCapabilityShaderViewportIndexLayerEXT,
    189           "ShaderViewportIndexLayerEXT"},
    190          {SpvCapabilityShaderViewportMaskNV, "ShaderViewportMaskNV"},
    191          {SpvCapabilityShaderStereoViewNV, "ShaderStereoViewNV"},
    192          {SpvCapabilityPerViewAttributesNV, "PerViewAttributesNV"}})), );
    193 
    194 }  // namespace
    195 }  // namespace spvtools
    196