1  //
2 // Copyright (C) 2016 Google, Inc.
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions
8 // are met:
9 //
10 //    Redistributions of source code must retain the above copyright
11 //    notice, this list of conditions and the following disclaimer.
12 //
13 //    Redistributions in binary form must reproduce the above
14 //    copyright notice, this list of conditions and the following
15 //    disclaimer in the documentation and/or other materials provided
16 //    with the distribution.
17 //
18 //    Neither the name of Google Inc. nor the names of its
19 //    contributors may be used to endorse or promote products derived
20 //    from this software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 // POSSIBILITY OF SUCH DAMAGE.
34 
35 #include <algorithm>
36 
37 #include <gtest/gtest.h>
38 
39 #include "TestFixture.h"
40 
41 namespace glslangtest {
42 namespace {
43 
44 struct IoMapData {
45     const char* fileName;
46     const char* entryPoint;
47     int baseSamplerBinding;
48     int baseTextureBinding;
49     int baseImageBinding;
50     int baseUboBinding;
51     int baseSsboBinding;
52     bool autoMapBindings;
53     bool flattenUniforms;
54 };
55 
FileNameAsCustomTestSuffixIoMap(const::testing::TestParamInfo<IoMapData> & info)56 std::string FileNameAsCustomTestSuffixIoMap(
57     const ::testing::TestParamInfo<IoMapData>& info) {
58     std::string name = info.param.fileName;
59     // A valid test case suffix cannot have '.' and '-' inside.
60     std::replace(name.begin(), name.end(), '.', '_');
61     std::replace(name.begin(), name.end(), '-', '_');
62     return name;
63 }
64 
65 using CompileVulkanToSpirvTest = GlslangTest<::testing::TestWithParam<std::string>>;
66 using CompileVulkanToDebugSpirvTest = GlslangTest<::testing::TestWithParam<std::string>>;
67 using CompileVulkan1_1ToSpirvTest = GlslangTest<::testing::TestWithParam<std::string>>;
68 using CompileOpenGLToSpirvTest = GlslangTest<::testing::TestWithParam<std::string>>;
69 using VulkanSemantics = GlslangTest<::testing::TestWithParam<std::string>>;
70 using OpenGLSemantics = GlslangTest<::testing::TestWithParam<std::string>>;
71 using VulkanAstSemantics = GlslangTest<::testing::TestWithParam<std::string>>;
72 using HlslIoMap = GlslangTest<::testing::TestWithParam<IoMapData>>;
73 using GlslIoMap = GlslangTest<::testing::TestWithParam<IoMapData>>;
74 #ifdef AMD_EXTENSIONS
75 using CompileVulkanToSpirvTestAMD = GlslangTest<::testing::TestWithParam<std::string>>;
76 #endif
77 #ifdef NV_EXTENSIONS
78 using CompileVulkanToSpirvTestNV = GlslangTest<::testing::TestWithParam<std::string>>;
79 #endif
80 using CompileUpgradeTextureToSampledTextureAndDropSamplersTest = GlslangTest<::testing::TestWithParam<std::string>>;
81 
82 // Compiling GLSL to SPIR-V under Vulkan semantics. Expected to successfully
83 // generate SPIR-V.
TEST_P(CompileVulkanToSpirvTest,FromFile)84 TEST_P(CompileVulkanToSpirvTest, FromFile)
85 {
86     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
87                             Source::GLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0,
88                             Target::Spv);
89 }
90 
91 // Compiling GLSL to SPIR-V with debug info under Vulkan semantics. Expected
92 // to successfully generate SPIR-V.
TEST_P(CompileVulkanToDebugSpirvTest,FromFile)93 TEST_P(CompileVulkanToDebugSpirvTest, FromFile)
94 {
95     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
96                             Source::GLSL, Semantics::Vulkan,
97                             glslang::EShTargetVulkan_1_0,
98                             Target::Spv, true, "",
99                             "/baseResults/", false, true);
100 }
101 
TEST_P(CompileVulkan1_1ToSpirvTest,FromFile)102 TEST_P(CompileVulkan1_1ToSpirvTest, FromFile)
103 {
104     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
105                             Source::GLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_1,
106                             Target::Spv);
107 }
108 
109 // Compiling GLSL to SPIR-V under OpenGL semantics. Expected to successfully
110 // generate SPIR-V.
TEST_P(CompileOpenGLToSpirvTest,FromFile)111 TEST_P(CompileOpenGLToSpirvTest, FromFile)
112 {
113     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
114                             Source::GLSL, Semantics::OpenGL, glslang::EShTargetVulkan_1_0,
115                             Target::Spv);
116 }
117 
118 // GLSL-level Vulkan semantics test. Expected to error out before generating
119 // SPIR-V.
TEST_P(VulkanSemantics,FromFile)120 TEST_P(VulkanSemantics, FromFile)
121 {
122     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
123                             Source::GLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0,
124                             Target::Spv, false);
125 }
126 
127 // GLSL-level Vulkan semantics test. Expected to error out before generating
128 // SPIR-V.
TEST_P(OpenGLSemantics,FromFile)129 TEST_P(OpenGLSemantics, FromFile)
130 {
131     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
132                             Source::GLSL, Semantics::OpenGL, glslang::EShTargetVulkan_1_0,
133                             Target::Spv, false);
134 }
135 
136 // GLSL-level Vulkan semantics test that need to see the AST for validation.
TEST_P(VulkanAstSemantics,FromFile)137 TEST_P(VulkanAstSemantics, FromFile)
138 {
139     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
140                             Source::GLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0,
141                             Target::AST);
142 }
143 
144 // HLSL-level Vulkan semantics tests.
TEST_P(HlslIoMap,FromFile)145 TEST_P(HlslIoMap, FromFile)
146 {
147     loadFileCompileIoMapAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
148                                  Source::HLSL, Semantics::Vulkan,
149                                  Target::Spv, GetParam().entryPoint,
150                                  GetParam().baseSamplerBinding,
151                                  GetParam().baseTextureBinding,
152                                  GetParam().baseImageBinding,
153                                  GetParam().baseUboBinding,
154                                  GetParam().baseSsboBinding,
155                                  GetParam().autoMapBindings,
156                                  GetParam().flattenUniforms);
157 }
158 
159 // GLSL-level Vulkan semantics tests.
TEST_P(GlslIoMap,FromFile)160 TEST_P(GlslIoMap, FromFile)
161 {
162     loadFileCompileIoMapAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
163                                  Source::GLSL, Semantics::Vulkan,
164                                  Target::Spv, GetParam().entryPoint,
165                                  GetParam().baseSamplerBinding,
166                                  GetParam().baseTextureBinding,
167                                  GetParam().baseImageBinding,
168                                  GetParam().baseUboBinding,
169                                  GetParam().baseSsboBinding,
170                                  GetParam().autoMapBindings,
171                                  GetParam().flattenUniforms);
172 }
173 
174 #ifdef AMD_EXTENSIONS
175 // Compiling GLSL to SPIR-V under Vulkan semantics (AMD extensions enabled).
176 // Expected to successfully generate SPIR-V.
TEST_P(CompileVulkanToSpirvTestAMD,FromFile)177 TEST_P(CompileVulkanToSpirvTestAMD, FromFile)
178 {
179     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
180                             Source::GLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0,
181                             Target::Spv);
182 }
183 #endif
184 
185 #ifdef NV_EXTENSIONS
186 // Compiling GLSL to SPIR-V under Vulkan semantics (NV extensions enabled).
187 // Expected to successfully generate SPIR-V.
TEST_P(CompileVulkanToSpirvTestNV,FromFile)188 TEST_P(CompileVulkanToSpirvTestNV, FromFile)
189 {
190     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam(),
191                             Source::GLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0,
192                             Target::Spv);
193 }
194 #endif
195 
TEST_P(CompileUpgradeTextureToSampledTextureAndDropSamplersTest,FromFile)196 TEST_P(CompileUpgradeTextureToSampledTextureAndDropSamplersTest, FromFile)
197 {
198     loadCompileUpgradeTextureToSampledTextureAndDropSamplersAndCheck(GlobalTestSettings.testRoot,
199                                                                      GetParam(),
200                                                                      Source::GLSL,
201                                                                      Semantics::Vulkan,
202                                                                      Target::Spv);
203 }
204 
205 // clang-format off
206 INSTANTIATE_TEST_CASE_P(
207     Glsl, CompileVulkanToSpirvTest,
208     ::testing::ValuesIn(std::vector<std::string>({
209         // Test looping constructs.
210         // No tests yet for making sure break and continue from a nested loop
211         // goes to the innermost target.
212         "spv.barrier.vert",
213         "spv.do-simple.vert",
214         "spv.do-while-continue-break.vert",
215         "spv.for-complex-condition.vert",
216         "spv.for-continue-break.vert",
217         "spv.for-simple.vert",
218         "spv.for-notest.vert",
219         "spv.for-nobody.vert",
220         "spv.while-continue-break.vert",
221         "spv.while-simple.vert",
222         // vulkan-specific tests
223         "spv.set.vert",
224         "spv.double.comp",
225         "spv.100ops.frag",
226         "spv.130.frag",
227         "spv.140.frag",
228         "spv.150.geom",
229         "spv.150.vert",
230         "spv.16bitstorage.frag",
231         "spv.16bitstorage_Error.frag",
232         "spv.16bitstorage-int.frag",
233         "spv.16bitstorage_Error-int.frag",
234         "spv.16bitstorage-uint.frag",
235         "spv.16bitstorage_Error-uint.frag",
236         "spv.300BuiltIns.vert",
237         "spv.300layout.frag",
238         "spv.300layout.vert",
239         "spv.300layoutp.vert",
240         "spv.310.comp",
241         "spv.310.bitcast.frag",
242         "spv.330.geom",
243         "spv.400.frag",
244         "spv.400.tesc",
245         "spv.400.tese",
246         "spv.420.geom",
247         "spv.430.frag",
248         "spv.430.vert",
249         "spv.450.tesc",
250         "spv.450.geom",
251         "spv.450.noRedecl.tesc",
252         "spv.8bitstorage-int.frag",
253         "spv.8bitstorage_Error-int.frag",
254         "spv.8bitstorage-uint.frag",
255         "spv.8bitstorage_Error-uint.frag",
256         "spv.8bitstorage-ubo.vert",
257         "spv.8bitstorage-ssbo.vert",
258         "spv.accessChain.frag",
259         "spv.aggOps.frag",
260         "spv.always-discard.frag",
261         "spv.always-discard2.frag",
262         "spv.arbPostDepthCoverage.frag",
263         "spv.arbPostDepthCoverage_Error.frag",
264         "spv.bitCast.frag",
265         "spv.bool.vert",
266         "spv.boolInBlock.frag",
267         "spv.branch-return.vert",
268         "spv.bufferhandle1.frag",
269         "spv.bufferhandle10.frag",
270         "spv.bufferhandle11.frag",
271         "spv.bufferhandle12.frag",
272         "spv.bufferhandle13.frag",
273         "spv.bufferhandle14.frag",
274         "spv.bufferhandle15.frag",
275         "spv.bufferhandle2.frag",
276         "spv.bufferhandle3.frag",
277         "spv.bufferhandle4.frag",
278         "spv.bufferhandle5.frag",
279         "spv.bufferhandle6.frag",
280         "spv.bufferhandle7.frag",
281         "spv.bufferhandle8.frag",
282         "spv.bufferhandle9.frag",
283         "spv.bufferhandle_Error.frag",
284         "spv.builtInXFB.vert",
285         "spv.conditionalDiscard.frag",
286         "spv.constStruct.vert",
287         "spv.controlFlowAttributes.frag",
288         "spv.conversion.frag",
289         "spv.dataOut.frag",
290         "spv.dataOutIndirect.frag",
291         "spv.dataOutIndirect.vert",
292         "spv.deepRvalue.frag",
293         "spv.depthOut.frag",
294         "spv.discard-dce.frag",
295         "spv.doWhileLoop.frag",
296         "spv.earlyReturnDiscard.frag",
297         "spv.extPostDepthCoverage.frag",
298         "spv.extPostDepthCoverage_Error.frag",
299         "spv.flowControl.frag",
300         "spv.forLoop.frag",
301         "spv.forwardFun.frag",
302         "spv.fragmentDensity.frag",
303         "spv.fragmentDensity.vert",
304         "spv.fragmentDensity-es.frag",
305         "spv.fragmentDensity-neg.frag",
306         "spv.fullyCovered.frag",
307         "spv.functionCall.frag",
308         "spv.functionNestedOpaque.vert",
309         "spv.functionSemantics.frag",
310         "spv.GeometryShaderPassthrough.geom",
311         "spv.interpOps.frag",
312         "spv.int64.frag",
313         "spv.intOps.vert",
314         "spv.layoutNested.vert",
315         "spv.length.frag",
316         "spv.localAggregates.frag",
317         "spv.loops.frag",
318         "spv.loopsArtificial.frag",
319         "spv.matFun.vert",
320         "spv.matrix.frag",
321         "spv.matrix2.frag",
322         "spv.memoryQualifier.frag",
323         "spv.merge-unreachable.frag",
324         "spv.multiStruct.comp",
325         "spv.multiStructFuncall.frag",
326         "spv.newTexture.frag",
327         "spv.noDeadDecorations.vert",
328         "spv.nonSquare.vert",
329         "spv.nonuniform.frag",
330         "spv.noWorkgroup.comp",
331         "spv.offsets.frag",
332         "spv.Operations.frag",
333         "spv.paramMemory.frag",
334         "spv.precision.frag",
335         "spv.precisionNonESSamp.frag",
336         "spv.prepost.frag",
337         "spv.qualifiers.vert",
338         "spv.sample.frag",
339         "spv.sampleId.frag",
340         "spv.samplePosition.frag",
341         "spv.sampleMaskOverrideCoverage.frag",
342         "spv.scalarlayout.frag",
343         "spv.scalarlayoutfloat16.frag",
344         "spv.shaderBallot.comp",
345         "spv.shaderDrawParams.vert",
346         "spv.shaderGroupVote.comp",
347         "spv.shaderStencilExport.frag",
348         "spv.shiftOps.frag",
349         "spv.simpleFunctionCall.frag",
350         "spv.simpleMat.vert",
351         "spv.sparseTexture.frag",
352         "spv.sparseTextureClamp.frag",
353         "spv.structAssignment.frag",
354         "spv.structDeref.frag",
355         "spv.structure.frag",
356         "spv.switch.frag",
357         "spv.swizzle.frag",
358         "spv.swizzleInversion.frag",
359         "spv.test.frag",
360         "spv.test.vert",
361         "spv.texture.frag",
362         "spv.texture.vert",
363         "spv.textureBuffer.vert",
364         "spv.image.frag",
365         "spv.types.frag",
366         "spv.uint.frag",
367         "spv.uniformArray.frag",
368         "spv.variableArrayIndex.frag",
369         "spv.varyingArray.frag",
370         "spv.varyingArrayIndirect.frag",
371         "spv.vecMatConstruct.frag",
372         "spv.voidFunction.frag",
373         "spv.whileLoop.frag",
374         "spv.AofA.frag",
375         "spv.queryL.frag",
376         "spv.separate.frag",
377         "spv.shortCircuit.frag",
378         "spv.pushConstant.vert",
379         "spv.pushConstantAnon.vert",
380         "spv.subpass.frag",
381         "spv.specConstant.vert",
382         "spv.specConstant.comp",
383         "spv.specConstantComposite.vert",
384         "spv.specConstantOperations.vert",
385         "spv.storageBuffer.vert",
386         "spv.precise.tese",
387         "spv.precise.tesc",
388         "spv.vulkan100.subgroupArithmetic.comp",
389         "spv.vulkan100.subgroupPartitioned.comp",
390         "spv.xfb.vert",
391         "spv.xfb2.vert",
392         "spv.xfb3.vert",
393         "spv.samplerlessTextureFunctions.frag",
394     })),
395     FileNameAsCustomTestSuffix
396 );
397 
398 // clang-format off
399 INSTANTIATE_TEST_CASE_P(
400     Glsl, CompileVulkanToDebugSpirvTest,
401     ::testing::ValuesIn(std::vector<std::string>({
402         "spv.pp.line.frag",
403     })),
404     FileNameAsCustomTestSuffix
405 );
406 
407 // clang-format off
408 INSTANTIATE_TEST_CASE_P(
409     Glsl, CompileVulkan1_1ToSpirvTest,
410     ::testing::ValuesIn(std::vector<std::string>({
411         "spv.1.3.8bitstorage-ubo.vert",
412         "spv.1.3.8bitstorage-ssbo.vert",
413         "spv.deviceGroup.frag",
414         "spv.drawParams.vert",
415         "spv.int8.frag",
416         "spv.vulkan110.int16.frag",
417         "spv.int32.frag",
418         "spv.explicittypes.frag",
419         "spv.float32.frag",
420         "spv.float64.frag",
421         "spv.memoryScopeSemantics.comp",
422         "spv.memoryScopeSemantics_Error.comp",
423         "spv.multiView.frag",
424         "spv.RayGenShader11.rgen",
425         "spv.subgroup.frag",
426         "spv.subgroup.geom",
427         "spv.subgroup.tesc",
428         "spv.subgroup.tese",
429         "spv.subgroup.vert",
430         "spv.subgroupArithmetic.comp",
431         "spv.subgroupBasic.comp",
432         "spv.subgroupBallot.comp",
433         "spv.subgroupBallotNeg.comp",
434         "spv.subgroupClustered.comp",
435         "spv.subgroupClusteredNeg.comp",
436         "spv.subgroupPartitioned.comp",
437         "spv.subgroupShuffle.comp",
438         "spv.subgroupShuffleRelative.comp",
439         "spv.subgroupQuad.comp",
440         "spv.subgroupVote.comp",
441         "spv.vulkan110.storageBuffer.vert",
442     })),
443     FileNameAsCustomTestSuffix
444 );
445 
446 // clang-format off
447 INSTANTIATE_TEST_CASE_P(
448     Hlsl, HlslIoMap,
449     ::testing::ValuesIn(std::vector<IoMapData>{
450         { "spv.register.autoassign.frag", "main_ep", 5, 10, 0, 20, 30, true, false },
451         { "spv.register.noautoassign.frag", "main_ep", 5, 10, 0, 15, 30, false, false },
452         { "spv.register.autoassign-2.frag", "main", 5, 10, 0, 15, 30, true, true },
453         { "spv.register.subpass.frag", "main", 0, 20, 0, 0, 0, true, true },
454         { "spv.buffer.autoassign.frag", "main", 5, 10, 0, 15, 30, true, true },
455         { "spv.ssbo.autoassign.frag", "main", 5, 10, 0, 15, 30, true, true },
456         { "spv.ssboAlias.frag", "main", 0, 0, 0, 0, 83, true, false },
457         { "spv.rw.autoassign.frag", "main", 5, 10, 20, 15, 30, true, true },
458         { "spv.register.autoassign.rangetest.frag", "main",
459                 glslang::TQualifier::layoutBindingEnd-2,
460                 glslang::TQualifier::layoutBindingEnd+5,
461                 20, 30, true, false },
462     }),
463     FileNameAsCustomTestSuffixIoMap
464 );
465 
466 // clang-format off
467 INSTANTIATE_TEST_CASE_P(
468     Hlsl, GlslIoMap,
469     ::testing::ValuesIn(std::vector<IoMapData>{
470         { "spv.glsl.register.autoassign.frag", "main", 5, 10, 0, 20, 30, true, false },
471         { "spv.glsl.register.noautoassign.frag", "main", 5, 10, 0, 15, 30, false, false },
472     }),
473     FileNameAsCustomTestSuffixIoMap
474 );
475 
476 // clang-format off
477 INSTANTIATE_TEST_CASE_P(
478     Glsl, CompileOpenGLToSpirvTest,
479     ::testing::ValuesIn(std::vector<std::string>({
480         "spv.460.frag",
481         "spv.460.vert",
482         "spv.460.comp",
483         "spv.atomic.comp",
484         "spv.glFragColor.frag",
485         "spv.rankShift.comp",
486         "spv.specConst.vert",
487         "spv.OVR_multiview.vert",
488         "spv.xfbOffsetOnBlockMembersAssignment.vert",
489         "spv.xfbOffsetOnStructMembersAssignment.vert",
490         "spv.xfbOverlapOffsetCheckWithBlockAndMember.vert",
491         "spv.xfbStrideJustOnce.vert",
492     })),
493     FileNameAsCustomTestSuffix
494 );
495 
496 INSTANTIATE_TEST_CASE_P(
497     Glsl, VulkanSemantics,
498     ::testing::ValuesIn(std::vector<std::string>({
499         "vulkan.frag",
500         "vulkan.vert",
501         "vulkan.comp",
502         "samplerlessTextureFunctions.frag",
503     })),
504     FileNameAsCustomTestSuffix
505 );
506 
507 INSTANTIATE_TEST_CASE_P(
508     Glsl, OpenGLSemantics,
509     ::testing::ValuesIn(std::vector<std::string>({
510         "glspv.esversion.vert",
511         "glspv.version.frag",
512         "glspv.version.vert",
513         "glspv.frag",
514         "glspv.vert",
515     })),
516     FileNameAsCustomTestSuffix
517 );
518 
519 INSTANTIATE_TEST_CASE_P(
520     Glsl, VulkanAstSemantics,
521     ::testing::ValuesIn(std::vector<std::string>({
522         "vulkan.ast.vert",
523     })),
524     FileNameAsCustomTestSuffix
525 );
526 
527 #ifdef AMD_EXTENSIONS
528 INSTANTIATE_TEST_CASE_P(
529     Glsl, CompileVulkanToSpirvTestAMD,
530     ::testing::ValuesIn(std::vector<std::string>({
531         "spv.float16.frag",
532         "spv.float16Fetch.frag",
533         "spv.imageLoadStoreLod.frag",
534         "spv.int16.frag",
535         "spv.int16.amd.frag",
536         "spv.shaderBallotAMD.comp",
537         "spv.shaderFragMaskAMD.frag",
538         "spv.textureGatherBiasLod.frag",
539     })),
540     FileNameAsCustomTestSuffix
541 );
542 #endif
543 
544 #ifdef NV_EXTENSIONS
545 INSTANTIATE_TEST_CASE_P(
546     Glsl, CompileVulkanToSpirvTestNV,
547     ::testing::ValuesIn(std::vector<std::string>({
548     "spv.sampleMaskOverrideCoverage.frag",
549     "spv.GeometryShaderPassthrough.geom",
550     "spv.viewportArray2.vert",
551     "spv.viewportArray2.tesc",
552     "spv.stereoViewRendering.vert",
553     "spv.stereoViewRendering.tesc",
554     "spv.multiviewPerViewAttributes.vert",
555     "spv.multiviewPerViewAttributes.tesc",
556     "spv.atomicInt64.comp",
557     "spv.shadingRate.frag",
558     "spv.RayGenShader.rgen",
559     "spv.RayGenShader_Errors.rgen",
560     "spv.RayConstants.rgen",
561     "spv.IntersectShader.rint",
562     "spv.IntersectShader_Errors.rint",
563     "spv.AnyHitShader.rahit",
564     "spv.AnyHitShader_Errors.rahit",
565     "spv.ClosestHitShader.rchit",
566     "spv.ClosestHitShader_Errors.rchit",
567     "spv.MissShader.rmiss",
568     "spv.MissShader_Errors.rmiss",
569     "spv.RayCallable.rcall",
570     "spv.RayCallable_Errors.rcall",
571     "spv.fragmentShaderBarycentric.frag",
572     "spv.fragmentShaderBarycentric2.frag",
573     "spv.computeShaderDerivatives.comp",
574     "spv.computeShaderDerivatives2.comp",
575     "spv.shaderImageFootprint.frag",
576     "spv.meshShaderBuiltins.mesh",
577     "spv.meshShaderUserDefined.mesh",
578     "spv.meshShaderPerViewBuiltins.mesh",
579     "spv.meshShaderPerViewUserDefined.mesh",
580     "spv.meshShaderSharedMem.mesh",
581     "spv.meshShaderTaskMem.mesh",
582     "spv.320.meshShaderUserDefined.mesh",
583     "spv.meshShaderRedeclBuiltins.mesh",
584     "spv.meshShaderRedeclPerViewBuiltins.mesh",
585     "spv.meshTaskShader.task",
586     "spv.perprimitiveNV.frag",
587 })),
588 FileNameAsCustomTestSuffix
589 );
590 #endif
591 
592 INSTANTIATE_TEST_CASE_P(
593     Glsl, CompileUpgradeTextureToSampledTextureAndDropSamplersTest,
594     ::testing::ValuesIn(std::vector<std::string>({
595       "spv.texture.sampler.transform.frag",
596     })),
597     FileNameAsCustomTestSuffix
598 );
599 // clang-format on
600 
601 }  // anonymous namespace
602 }  // namespace glslangtest
603