external/glslang/src/gtests/Hlsl.FromFile.cpp

   1 //
   2 // Copyright (C) 2016 Google, Inc.
   3 // Copyright (C) 2016 LunarG, Inc.
   4 //
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 //
  11 //    Redistributions of source code must retain the above copyright
  12 //    notice, this list of conditions and the following disclaimer.
  13 //
  14 //    Redistributions in binary form must reproduce the above
  15 //    copyright notice, this list of conditions and the following
  16 //    disclaimer in the documentation and/or other materials provided
  17 //    with the distribution.
  18 //
  19 //    Neither the name of Google Inc. nor the names of its
  20 //    contributors may be used to endorse or promote products derived
  21 //    from this software without specific prior written permission.
  22 //
  23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  27 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  33 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34 // POSSIBILITY OF SUCH DAMAGE.
  35
  36 #include <gtest/gtest.h>
  37
  38 #include "TestFixture.h"
  39
  40 namespace glslangtest {
  41 namespace {
  42
  43 struct FileNameEntryPointPair {
  44   const char* fileName;
  45   const char* entryPoint;
  46 };
  47
  48 // We are using FileNameEntryPointPair objects as parameters for instantiating
  49 // the template, so the global FileNameAsCustomTestSuffix() won't work since
  50 // it assumes std::string as parameters. Thus, an overriding one here.
  51 std::string FileNameAsCustomTestSuffix(
  52     const ::testing::TestParamInfo<FileNameEntryPointPair>& info) {
  53     std::string name = info.param.fileName;
  54     // A valid test case suffix cannot have '.' and '-' inside.
  55     std::replace(name.begin(), name.end(), '.', '_');
  56     std::replace(name.begin(), name.end(), '-', '_');
  57     return name;
  58 }
  59
  60 using HlslCompileTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
  61 using HlslCompileAndFlattenTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
  62
  63 // Compiling HLSL to SPIR-V under Vulkan semantics. Expected to successfully
  64 // generate both AST and SPIR-V.
  65 TEST_P(HlslCompileTest, FromFile)
  66 {
  67     loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
  68                             Source::HLSL, Semantics::Vulkan,
  69                             Target::BothASTAndSpv, GetParam().entryPoint);
  70 }
  71
  72 TEST_P(HlslCompileAndFlattenTest, FromFile)
  73 {
  74     loadFileCompileFlattenUniformsAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
  75                                            Source::HLSL, Semantics::Vulkan,
  76                                            Target::BothASTAndSpv, GetParam().entryPoint);
  77 }
  78
  79 // clang-format off
  80 INSTANTIATE_TEST_CASE_P(
  81     ToSpirv, HlslCompileTest,
  82     ::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
  83         {"hlsl.amend.frag", "f1"},
  84         {"hlsl.array.frag", "PixelShaderFunction"},
  85         {"hlsl.array.implicit-size.frag", "PixelShaderFunction"},
  86         {"hlsl.array.multidim.frag", "main"},
  87         {"hlsl.assoc.frag", "PixelShaderFunction"},
  88         {"hlsl.attribute.frag", "PixelShaderFunction"},
  89         {"hlsl.attribute.expression.comp", "main"},
  90         {"hlsl.basic.comp", "main"},
  91         {"hlsl.basic.geom", "main"},
  92         {"hlsl.boolConv.vert", "main"},
  93         {"hlsl.buffer.frag", "PixelShaderFunction"},
  94         {"hlsl.calculatelod.dx10.frag", "main"},
  95         {"hlsl.calculatelodunclamped.dx10.frag", "main"},
  96         {"hlsl.cast.frag", "PixelShaderFunction"},
  97         {"hlsl.charLit.vert", "main"},
  98         {"hlsl.clip.frag", "main"},
  99         {"hlsl.comparison.vec.frag", "main"},
 100         {"hlsl.conditional.frag", "PixelShaderFunction"},
 101         {"hlsl.constantbuffer.frag", "main"},
 102         {"hlsl.constructexpr.frag", "main"},
 103         {"hlsl.depthGreater.frag", "PixelShaderFunction"},
 104         {"hlsl.depthLess.frag", "PixelShaderFunction"},
 105         {"hlsl.discard.frag", "PixelShaderFunction"},
 106         {"hlsl.doLoop.frag", "PixelShaderFunction"},
 107         {"hlsl.emptystructreturn.frag", "main"},
 108         {"hlsl.emptystructreturn.vert", "main"},
 109         {"hlsl.emptystruct.init.vert", "main"},
 110         {"hlsl.entry-in.frag", "PixelShaderFunction"},
 111         {"hlsl.entry-out.frag", "PixelShaderFunction"},
 112         {"hlsl.float1.frag", "PixelShaderFunction"},
 113         {"hlsl.float4.frag", "PixelShaderFunction"},
 114         {"hlsl.flatten.return.frag", "main"},
 115         {"hlsl.forLoop.frag", "PixelShaderFunction"},
 116         {"hlsl.gather.array.dx10.frag", "main"},
 117         {"hlsl.gather.basic.dx10.frag", "main"},
 118         {"hlsl.gather.basic.dx10.vert", "main"},
 119         {"hlsl.gather.offset.dx10.frag", "main"},
 120         {"hlsl.gather.offsetarray.dx10.frag", "main"},
 121         {"hlsl.gathercmpRGBA.offset.dx10.frag", "main"},
 122         {"hlsl.gatherRGBA.array.dx10.frag", "main"},
 123         {"hlsl.gatherRGBA.basic.dx10.frag", "main"},
 124         {"hlsl.gatherRGBA.offset.dx10.frag", "main"},
 125         {"hlsl.gatherRGBA.offsetarray.dx10.frag", "main"},
 126         {"hlsl.getdimensions.dx10.frag", "main"},
 127         {"hlsl.getdimensions.rw.dx10.frag", "main"},
 128         {"hlsl.getdimensions.dx10.vert", "main"},
 129         {"hlsl.getsampleposition.dx10.frag", "main"},
 130         {"hlsl.domain.1.tese", "main"},
 131         {"hlsl.domain.2.tese", "main"},
 132         {"hlsl.domain.3.tese", "main"},
 133         {"hlsl.hull.1.tesc", "main"},
 134         {"hlsl.hull.2.tesc", "main"},
 135         {"hlsl.hull.void.tesc", "main"},
 136         {"hlsl.hull.ctrlpt-1.tesc", "main"},
 137         {"hlsl.hull.ctrlpt-2.tesc", "main"},
 138         {"hlsl.identifier.sample.frag", "main"},
 139         {"hlsl.if.frag", "PixelShaderFunction"},
 140         {"hlsl.implicitBool.frag", "main"},
 141         {"hlsl.inf.vert", "main"},
 142         {"hlsl.inoutquals.frag", "main"},
 143         {"hlsl.init.frag", "ShaderFunction"},
 144         {"hlsl.init2.frag", "main"},
 145         {"hlsl.isfinite.frag", "main"},
 146         {"hlsl.intrinsics.barriers.comp", "ComputeShaderFunction"},
 147         {"hlsl.intrinsics.comp", "ComputeShaderFunction"},
 148         {"hlsl.intrinsics.evalfns.frag", "main"},
 149         {"hlsl.intrinsics.d3dcolortoubyte4.frag", "main"},
 150         {"hlsl.intrinsics.double.frag", "PixelShaderFunction"},
 151         {"hlsl.intrinsics.f1632.frag", "main"},
 152         {"hlsl.intrinsics.f3216.frag", "main"},
 153         {"hlsl.intrinsics.frag", "main"},
 154         {"hlsl.intrinsic.frexp.frag", "main"},
 155         {"hlsl.intrinsics.lit.frag", "PixelShaderFunction"},
 156         {"hlsl.intrinsics.negative.comp", "ComputeShaderFunction"},
 157         {"hlsl.intrinsics.negative.frag", "PixelShaderFunction"},
 158         {"hlsl.intrinsics.negative.vert", "VertexShaderFunction"},
 159         {"hlsl.intrinsics.promote.frag", "main"},
 160         {"hlsl.intrinsics.promote.down.frag", "main"},
 161         {"hlsl.intrinsics.promote.outputs.frag", "main"},
 162         {"hlsl.layout.frag", "main"},
 163         {"hlsl.load.2dms.dx10.frag", "main"},
 164         {"hlsl.load.array.dx10.frag", "main"},
 165         {"hlsl.load.basic.dx10.frag", "main"},
 166         {"hlsl.load.basic.dx10.vert", "main"},
 167         {"hlsl.load.buffer.dx10.frag", "main"},
 168         {"hlsl.load.buffer.float.dx10.frag", "main"},
 169         {"hlsl.load.rwbuffer.dx10.frag", "main"},
 170         {"hlsl.load.rwtexture.dx10.frag", "main"},
 171         {"hlsl.load.rwtexture.array.dx10.frag", "main"},
 172         {"hlsl.load.offset.dx10.frag", "main"},
 173         {"hlsl.load.offsetarray.dx10.frag", "main"},
 174         {"hlsl.logical.binary.frag", "main"},
 175         {"hlsl.logical.binary.vec.frag", "main"},
 176         {"hlsl.logicalConvert.frag", "main"},
 177         {"hlsl.logical.unary.frag", "main"},
 178         {"hlsl.loopattr.frag", "main"},
 179         {"hlsl.namespace.frag", "main"},
 180         {"hlsl.nonint-index.frag", "main"},
 181         {"hlsl.matNx1.frag", "main"},
 182         {"hlsl.matrixSwizzle.vert", "ShaderFunction"},
 183         {"hlsl.mintypes.frag", "main"},
 184         {"hlsl.multiEntry.vert", "RealEntrypoint"},
 185         {"hlsl.multiReturn.frag", "main"},
 186         {"hlsl.matrixindex.frag", "main"},
 187         {"hlsl.nonstaticMemberFunction.frag", "main"},
 188         {"hlsl.numericsuffixes.frag", "main"},
 189         {"hlsl.numthreads.comp", "main_aux1"},
 190         {"hlsl.overload.frag", "PixelShaderFunction"},
 191         {"hlsl.params.default.frag", "main"},
 192         {"hlsl.params.default.negative.frag", "main"},
 193         {"hlsl.partialInit.frag", "PixelShaderFunction"},
 194         {"hlsl.pp.line.frag", "main"},
 195         {"hlsl.precise.frag", "main"},
 196         {"hlsl.promote.atomic.frag", "main"},
 197         {"hlsl.promote.binary.frag", "main"},
 198         {"hlsl.promote.vec1.frag", "main"},
 199         {"hlsl.promotions.frag", "main"},
 200         {"hlsl.rw.atomics.frag", "main"},
 201         {"hlsl.rw.bracket.frag", "main"},
 202         {"hlsl.rw.register.frag", "main"},
 203         {"hlsl.rw.scalar.bracket.frag", "main"},
 204         {"hlsl.rw.swizzle.frag", "main"},
 205         {"hlsl.rw.vec2.bracket.frag", "main"},
 206         {"hlsl.sample.array.dx10.frag", "main"},
 207         {"hlsl.sample.basic.dx10.frag", "main"},
 208         {"hlsl.sample.offset.dx10.frag", "main"},
 209         {"hlsl.sample.offsetarray.dx10.frag", "main"},
 210         {"hlsl.samplebias.array.dx10.frag", "main"},
 211         {"hlsl.samplebias.basic.dx10.frag", "main"},
 212         {"hlsl.samplebias.offset.dx10.frag", "main"},
 213         {"hlsl.samplebias.offsetarray.dx10.frag", "main"},
 214         {"hlsl.samplecmp.array.dx10.frag", "main"},
 215         {"hlsl.samplecmp.basic.dx10.frag", "main"},
 216         {"hlsl.samplecmp.offset.dx10.frag", "main"},
 217         {"hlsl.samplecmp.offsetarray.dx10.frag", "main"},
 218         {"hlsl.samplecmp.negative.frag", "main"},
 219         {"hlsl.samplecmp.negative2.frag", "main"},
 220         {"hlsl.samplecmplevelzero.array.dx10.frag", "main"},
 221         {"hlsl.samplecmplevelzero.basic.dx10.frag", "main"},
 222         {"hlsl.samplecmplevelzero.offset.dx10.frag", "main"},
 223         {"hlsl.samplecmplevelzero.offsetarray.dx10.frag", "main"},
 224         {"hlsl.samplegrad.array.dx10.frag", "main"},
 225         {"hlsl.samplegrad.basic.dx10.frag", "main"},
 226         {"hlsl.samplegrad.basic.dx10.vert", "main"},
 227         {"hlsl.samplegrad.offset.dx10.frag", "main"},
 228         {"hlsl.samplegrad.offsetarray.dx10.frag", "main"},
 229         {"hlsl.samplelevel.array.dx10.frag", "main"},
 230         {"hlsl.samplelevel.basic.dx10.frag", "main"},
 231         {"hlsl.samplelevel.basic.dx10.vert", "main"},
 232         {"hlsl.samplelevel.offset.dx10.frag", "main"},
 233         {"hlsl.samplelevel.offsetarray.dx10.frag", "main"},
 234         {"hlsl.sample.sub-vec4.dx10.frag", "main"},
 235         {"hlsl.scalar-length.frag", "main"},
 236         {"hlsl.scalarCast.vert", "main"},
 237         {"hlsl.semicolons.frag", "main"},
 238         {"hlsl.shapeConv.frag", "main"},
 239         {"hlsl.shapeConvRet.frag", "main"},
 240         {"hlsl.staticMemberFunction.frag", "main"},
 241         {"hlsl.stringtoken.frag", "main"},
 242         {"hlsl.string.frag", "main"},
 243         {"hlsl.struct.split-1.vert", "main"},
 244         {"hlsl.struct.split.array.geom", "main"},
 245         {"hlsl.struct.split.assign.frag", "main"},
 246         {"hlsl.struct.split.call.vert", "main"},
 247         {"hlsl.struct.split.nested.geom", "main"},
 248         {"hlsl.struct.split.trivial.geom", "main"},
 249         {"hlsl.struct.split.trivial.vert", "main"},
 250         {"hlsl.structarray.flatten.frag", "main"},
 251         {"hlsl.structarray.flatten.geom", "main"},
 252         {"hlsl.structbuffer.frag", "main"},
 253         {"hlsl.structbuffer.append.frag", "main"},
 254         {"hlsl.structbuffer.atomics.frag", "main"},
 255         {"hlsl.structbuffer.byte.frag", "main"},
 256         {"hlsl.structbuffer.coherent.frag", "main"},
 257         {"hlsl.structbuffer.floatidx.comp", "main"},
 258         {"hlsl.structbuffer.incdec.frag", "main"},
 259         {"hlsl.structbuffer.fn.frag", "main"},
 260         {"hlsl.structbuffer.fn2.comp", "main"},
 261         {"hlsl.structbuffer.rw.frag", "main"},
 262         {"hlsl.structbuffer.rwbyte.frag", "main"},
 263         {"hlsl.structin.vert", "main"},
 264         {"hlsl.structIoFourWay.frag", "main"},
 265         {"hlsl.structStructName.frag", "main"},
 266         {"hlsl.this.frag", "main"},
 267         {"hlsl.intrinsics.vert", "VertexShaderFunction"},
 268         {"hlsl.intrinsic.frexp.vert", "VertexShaderFunction"},
 269         {"hlsl.matType.frag", "PixelShaderFunction"},
 270         {"hlsl.matType.bool.frag", "main"},
 271         {"hlsl.matType.int.frag", "main"},
 272         {"hlsl.max.frag", "PixelShaderFunction"},
 273         {"hlsl.precedence.frag", "PixelShaderFunction"},
 274         {"hlsl.precedence2.frag", "PixelShaderFunction"},
 275         {"hlsl.semantic.geom", "main"},
 276         {"hlsl.semantic.vert", "main"},
 277         {"hlsl.scope.frag", "PixelShaderFunction"},
 278         {"hlsl.sin.frag", "PixelShaderFunction"},
 279         {"hlsl.struct.frag", "PixelShaderFunction"},
 280         {"hlsl.switch.frag", "PixelShaderFunction"},
 281         {"hlsl.swizzle.frag", "PixelShaderFunction"},
 282         {"hlsl.templatetypes.frag", "PixelShaderFunction"},
 283         {"hlsl.tx.bracket.frag", "main"},
 284         {"hlsl.type.half.frag", "main"},
 285         {"hlsl.type.identifier.frag", "main"},
 286         {"hlsl.typeGraphCopy.vert", "main"},
 287         {"hlsl.typedef.frag", "PixelShaderFunction"},
 288         {"hlsl.whileLoop.frag", "PixelShaderFunction"},
 289         {"hlsl.void.frag", "PixelShaderFunction"},
 290     }),
 291     FileNameAsCustomTestSuffix
 292 );
 293 // clang-format on
 294
 295 // clang-format off
 296 INSTANTIATE_TEST_CASE_P(
 297     ToSpirv, HlslCompileAndFlattenTest,
 298     ::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
 299         {"hlsl.array.flatten.frag", "main"},
 300     }),
 301     FileNameAsCustomTestSuffix
 302 );
 303
 304 // clang-format on
 305 }  // anonymous namespace
 306 }  // namespace glslangtest