• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2017 Google Inc.
2 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights
3 // reserved.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 //     http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 
17 // Tests for OpExtension validator rules.
18 
19 #include <string>
20 #include <utility>
21 #include <vector>
22 
23 #include "gtest/gtest.h"
24 #include "source/enum_string_mapping.h"
25 #include "source/extensions.h"
26 
27 namespace spvtools {
28 namespace {
29 
30 using ::testing::Values;
31 using ::testing::ValuesIn;
32 
33 using ExtensionTest =
34     ::testing::TestWithParam<std::pair<Extension, std::string>>;
35 using UnknownExtensionTest = ::testing::TestWithParam<std::string>;
36 using CapabilityTest =
37     ::testing::TestWithParam<std::pair<spv::Capability, std::string>>;
38 
TEST_P(ExtensionTest,TestExtensionFromString)39 TEST_P(ExtensionTest, TestExtensionFromString) {
40   const std::pair<Extension, std::string>& param = GetParam();
41   const Extension extension = param.first;
42   const std::string extension_str = param.second;
43   Extension result_extension;
44   ASSERT_TRUE(GetExtensionFromString(extension_str.c_str(), &result_extension));
45   EXPECT_EQ(extension, result_extension);
46 }
47 
TEST_P(ExtensionTest,TestExtensionToString)48 TEST_P(ExtensionTest, TestExtensionToString) {
49   const std::pair<Extension, std::string>& param = GetParam();
50   const Extension extension = param.first;
51   const std::string extension_str = param.second;
52   const std::string result_str = ExtensionToString(extension);
53   EXPECT_EQ(extension_str, result_str);
54 }
55 
TEST_P(UnknownExtensionTest,TestExtensionFromStringFails)56 TEST_P(UnknownExtensionTest, TestExtensionFromStringFails) {
57   Extension result_extension;
58   ASSERT_FALSE(GetExtensionFromString(GetParam().c_str(), &result_extension));
59 }
60 
TEST_P(CapabilityTest,TestCapabilityToString)61 TEST_P(CapabilityTest, TestCapabilityToString) {
62   const std::pair<spv::Capability, std::string>& param = GetParam();
63   const spv::Capability capability = param.first;
64   const std::string capability_str = param.second;
65   const std::string result_str = CapabilityToString(capability);
66   EXPECT_EQ(capability_str, result_str);
67 }
68 
69 INSTANTIATE_TEST_SUITE_P(
70     AllExtensions, ExtensionTest,
71     ValuesIn(std::vector<std::pair<Extension, std::string>>({
72         {Extension::kSPV_KHR_16bit_storage, "SPV_KHR_16bit_storage"},
73         {Extension::kSPV_KHR_device_group, "SPV_KHR_device_group"},
74         {Extension::kSPV_KHR_multiview, "SPV_KHR_multiview"},
75         {Extension::kSPV_KHR_shader_ballot, "SPV_KHR_shader_ballot"},
76         {Extension::kSPV_KHR_shader_draw_parameters,
77          "SPV_KHR_shader_draw_parameters"},
78         {Extension::kSPV_KHR_subgroup_vote, "SPV_KHR_subgroup_vote"},
79         {Extension::kSPV_NVX_multiview_per_view_attributes,
80          "SPV_NVX_multiview_per_view_attributes"},
81         {Extension::kSPV_NV_geometry_shader_passthrough,
82          "SPV_NV_geometry_shader_passthrough"},
83         {Extension::kSPV_NV_sample_mask_override_coverage,
84          "SPV_NV_sample_mask_override_coverage"},
85         {Extension::kSPV_NV_stereo_view_rendering,
86          "SPV_NV_stereo_view_rendering"},
87         {Extension::kSPV_NV_viewport_array2, "SPV_NV_viewport_array2"},
88         {Extension::kSPV_GOOGLE_decorate_string, "SPV_GOOGLE_decorate_string"},
89         {Extension::kSPV_GOOGLE_hlsl_functionality1,
90          "SPV_GOOGLE_hlsl_functionality1"},
91         {Extension::kSPV_KHR_8bit_storage, "SPV_KHR_8bit_storage"},
92     })));
93 
94 INSTANTIATE_TEST_SUITE_P(UnknownExtensions, UnknownExtensionTest,
95                          Values("", "SPV_KHR_", "SPV_KHR_device_group_ERROR",
96                                 /*alphabetically before all extensions*/ "A",
97                                 /*alphabetically after all extensions*/ "Z",
98                                 "SPV_ERROR_random_string_hfsdklhlktherh"));
99 
100 INSTANTIATE_TEST_SUITE_P(
101     AllCapabilities, CapabilityTest,
102     ValuesIn(std::vector<std::pair<spv::Capability, std::string>>(
103         {{spv::Capability::Matrix, "Matrix"},
104          {spv::Capability::Shader, "Shader"},
105          {spv::Capability::Geometry, "Geometry"},
106          {spv::Capability::Tessellation, "Tessellation"},
107          {spv::Capability::Addresses, "Addresses"},
108          {spv::Capability::Linkage, "Linkage"},
109          {spv::Capability::Kernel, "Kernel"},
110          {spv::Capability::Vector16, "Vector16"},
111          {spv::Capability::Float16Buffer, "Float16Buffer"},
112          {spv::Capability::Float16, "Float16"},
113          {spv::Capability::Float64, "Float64"},
114          {spv::Capability::Int64, "Int64"},
115          {spv::Capability::Int64Atomics, "Int64Atomics"},
116          {spv::Capability::ImageBasic, "ImageBasic"},
117          {spv::Capability::ImageReadWrite, "ImageReadWrite"},
118          {spv::Capability::ImageMipmap, "ImageMipmap"},
119          {spv::Capability::Pipes, "Pipes"},
120          {spv::Capability::Groups, "Groups"},
121          {spv::Capability::DeviceEnqueue, "DeviceEnqueue"},
122          {spv::Capability::LiteralSampler, "LiteralSampler"},
123          {spv::Capability::AtomicStorage, "AtomicStorage"},
124          {spv::Capability::Int16, "Int16"},
125          {spv::Capability::TessellationPointSize, "TessellationPointSize"},
126          {spv::Capability::GeometryPointSize, "GeometryPointSize"},
127          {spv::Capability::ImageGatherExtended, "ImageGatherExtended"},
128          {spv::Capability::StorageImageMultisample, "StorageImageMultisample"},
129          {spv::Capability::UniformBufferArrayDynamicIndexing,
130           "UniformBufferArrayDynamicIndexing"},
131          {spv::Capability::SampledImageArrayDynamicIndexing,
132           "SampledImageArrayDynamicIndexing"},
133          {spv::Capability::StorageBufferArrayDynamicIndexing,
134           "StorageBufferArrayDynamicIndexing"},
135          {spv::Capability::StorageImageArrayDynamicIndexing,
136           "StorageImageArrayDynamicIndexing"},
137          {spv::Capability::ClipDistance, "ClipDistance"},
138          {spv::Capability::CullDistance, "CullDistance"},
139          {spv::Capability::ImageCubeArray, "ImageCubeArray"},
140          {spv::Capability::SampleRateShading, "SampleRateShading"},
141          {spv::Capability::ImageRect, "ImageRect"},
142          {spv::Capability::SampledRect, "SampledRect"},
143          {spv::Capability::GenericPointer, "GenericPointer"},
144          {spv::Capability::Int8, "Int8"},
145          {spv::Capability::InputAttachment, "InputAttachment"},
146          {spv::Capability::SparseResidency, "SparseResidency"},
147          {spv::Capability::MinLod, "MinLod"},
148          {spv::Capability::Sampled1D, "Sampled1D"},
149          {spv::Capability::Image1D, "Image1D"},
150          {spv::Capability::SampledCubeArray, "SampledCubeArray"},
151          {spv::Capability::SampledBuffer, "SampledBuffer"},
152          {spv::Capability::ImageBuffer, "ImageBuffer"},
153          {spv::Capability::ImageMSArray, "ImageMSArray"},
154          {spv::Capability::StorageImageExtendedFormats,
155           "StorageImageExtendedFormats"},
156          {spv::Capability::ImageQuery, "ImageQuery"},
157          {spv::Capability::DerivativeControl, "DerivativeControl"},
158          {spv::Capability::InterpolationFunction, "InterpolationFunction"},
159          {spv::Capability::TransformFeedback, "TransformFeedback"},
160          {spv::Capability::GeometryStreams, "GeometryStreams"},
161          {spv::Capability::StorageImageReadWithoutFormat,
162           "StorageImageReadWithoutFormat"},
163          {spv::Capability::StorageImageWriteWithoutFormat,
164           "StorageImageWriteWithoutFormat"},
165          {spv::Capability::MultiViewport, "MultiViewport"},
166          {spv::Capability::SubgroupDispatch, "SubgroupDispatch"},
167          {spv::Capability::NamedBarrier, "NamedBarrier"},
168          {spv::Capability::PipeStorage, "PipeStorage"},
169          {spv::Capability::SubgroupBallotKHR, "SubgroupBallotKHR"},
170          {spv::Capability::DrawParameters, "DrawParameters"},
171          {spv::Capability::SubgroupVoteKHR, "SubgroupVoteKHR"},
172          {spv::Capability::StorageBuffer16BitAccess,
173           "StorageBuffer16BitAccess"},
174          {spv::Capability::StorageUniformBufferBlock16,
175           "StorageBuffer16BitAccess"},  // Preferred name
176          {spv::Capability::UniformAndStorageBuffer16BitAccess,
177           "UniformAndStorageBuffer16BitAccess"},
178          {spv::Capability::StorageUniform16,
179           "UniformAndStorageBuffer16BitAccess"},  // Preferred name
180          {spv::Capability::StoragePushConstant16, "StoragePushConstant16"},
181          {spv::Capability::StorageInputOutput16, "StorageInputOutput16"},
182          {spv::Capability::DeviceGroup, "DeviceGroup"},
183          {spv::Capability::AtomicFloat32AddEXT, "AtomicFloat32AddEXT"},
184          {spv::Capability::AtomicFloat64AddEXT, "AtomicFloat64AddEXT"},
185          {spv::Capability::AtomicFloat32MinMaxEXT, "AtomicFloat32MinMaxEXT"},
186          {spv::Capability::AtomicFloat64MinMaxEXT, "AtomicFloat64MinMaxEXT"},
187          {spv::Capability::MultiView, "MultiView"},
188          {spv::Capability::Int64ImageEXT, "Int64ImageEXT"},
189          {spv::Capability::SampleMaskOverrideCoverageNV,
190           "SampleMaskOverrideCoverageNV"},
191          {spv::Capability::GeometryShaderPassthroughNV,
192           "GeometryShaderPassthroughNV"},
193          // The next two are different names for the same token.
194          {spv::Capability::ShaderViewportIndexLayerNV,
195           "ShaderViewportIndexLayerEXT"},
196          {spv::Capability::ShaderViewportIndexLayerEXT,
197           "ShaderViewportIndexLayerEXT"},
198          {spv::Capability::ShaderViewportMaskNV, "ShaderViewportMaskNV"},
199          {spv::Capability::ShaderStereoViewNV, "ShaderStereoViewNV"},
200          {spv::Capability::PerViewAttributesNV, "PerViewAttributesNV"}})));
201 
202 }  // namespace
203 }  // namespace spvtools
204