Test compiling shaders with given resource limits using GTest.

StandAlone/ResourceLimits.h

@@ -49,6 +49,9 @@ extern const TBuiltInResource DefaultTBuiltInResource;
 // Returns the DefaultTBuiltInResource as a human-readable string.
 std::string GetDefaultTBuiltInResourceString();
 
+// Decodes the resource limits from |config| to |resources|.
+void DecodeResourceLimits(TBuiltInResource* resources, char* config);
+
 }  // end namespace glslang
 
 #endif  // _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_

Test/baseResults/100LimitsConf.vert.out

@@ -22,3 +22,7 @@ ERROR: 0:65: 'limitations' : Non-constant-index-expression
 ERROR: 20 compilation errors.  No code generated.
 
 
+
+Linked vertex stage:
+
+

Test/runtests

@@ -14,7 +14,7 @@ $EXE -c > $TARGETDIR/test.conf
 diff -b $BASEDIR/test.conf $TARGETDIR/test.conf || HASERROR=1
 $EXE -i -l $TARGETDIR/test.conf specExamples.vert > $TARGETDIR/specExamples.vert.out
 diff -b $BASEDIR/specExamples.vert.out $TARGETDIR || HASERROR=1
-$EXE 100Limits.vert 100.conf >  $TARGETDIR/100LimitsConf.vert.out
+$EXE -l 100Limits.vert 100.conf >  $TARGETDIR/100LimitsConf.vert.out
 diff -b $BASEDIR/100LimitsConf.vert.out $TARGETDIR/100LimitsConf.vert.out || HASERROR=1
 
 #

gtests/CMakeLists.txt

@@ -13,6 +13,7 @@ if (TARGET gmock)
     # Test related source files
     ${CMAKE_CURRENT_SOURCE_DIR}/AST.FromFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/BuiltInResource.FromFile.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/Config.FromFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Hlsl.FromFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Link.FromFile.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Pp.FromFile.cpp

gtests/Config.FromFile.cpp

+//
+// Copyright (C) 2016 Google, Inc.
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of Google Inc. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#include "StandAlone/ResourceLimits.h"
+#include "TestFixture.h"
+
+namespace glslangtest {
+namespace {
+
+struct TestCaseSpec {
+    std::string input;
+    std::string config;
+    std::string output;
+    EShMessages controls;
+};
+
+using ConfigTest = GlslangTest<::testing::TestWithParam<TestCaseSpec>>;
+
+TEST_P(ConfigTest, FromFile)
+{
+    TestCaseSpec testCase = GetParam();
+    GlslangResult result;
+
+    // Get the contents for input shader and limit configurations.
+    std::string shaderContents, configContents;
+    tryLoadFile(GLSLANG_TEST_DIRECTORY "/" + testCase.input, "input", &shaderContents);
+    tryLoadFile(GLSLANG_TEST_DIRECTORY "/" + testCase.config, "limits config", &configContents);
+
+    // Decode limit configurations.
+    TBuiltInResource resources = {};
+    {
+        const size_t len = configContents.size();
+        char* configChars = new char[len + 1];
+        memcpy(configChars, configContents.data(), len);
+        configChars[len] = 0;
+        glslang::DecodeResourceLimits(&resources, configChars);
+        delete[] configChars;
+    }
+
+    // Compile the shader.
+    glslang::TShader shader(GetShaderStage(GetSuffix(testCase.input)));
+    compile(&shader, shaderContents, "", testCase.controls, &resources);
+    result.shaderResults.push_back(
+        {testCase.input, shader.getInfoLog(), shader.getInfoDebugLog()});
+
+    // Link the shader.
+    glslang::TProgram program;
+    program.addShader(&shader);
+    program.link(testCase.controls);
+    result.linkingOutput = program.getInfoLog();
+    result.linkingError = program.getInfoDebugLog();
+
+    std::ostringstream stream;
+    outputResultToStream(&stream, result, testCase.controls);
+
+    // Check with expected results.
+    const std::string expectedOutputFname =
+        GLSLANG_TEST_DIRECTORY "/baseResults/" + testCase.output;
+    std::string expectedOutput;
+    tryLoadFile(expectedOutputFname, "expected output", &expectedOutput);
+
+    checkEqAndUpdateIfRequested(expectedOutput, stream.str(), expectedOutputFname);
+}
+
+// clang-format off
+INSTANTIATE_TEST_CASE_P(
+    Glsl, ConfigTest,
+    ::testing::ValuesIn(std::vector<TestCaseSpec>({
+        {"specExamples.vert", "baseResults/test.conf", "specExamples.vert.out", EShMsgAST},
+        {"100Limits.vert", "100.conf", "100LimitsConf.vert.out", EShMsgDefault},
+    })),
+);
+// clang-format on
+
+}  // anonymous namespace
+}  // namespace glslangtest

gtests/TestFixture.h

@@ -171,7 +171,8 @@ public:
     // the target under the semantics conveyed via |controls|. Returns true
     // and modifies |shader| on success.
     bool compile(glslang::TShader* shader, const std::string& code,
-                 const std::string& entryPointName, EShMessages controls)
+                 const std::string& entryPointName, EShMessages controls,
+                 const TBuiltInResource* resources=nullptr)
     {
         const char* shaderStrings = code.data();
         const int shaderLengths = static_cast<int>(code.size());
@@ -181,8 +182,9 @@ public:
         // Reinitialize glslang if the semantics change.
         GlslangInitializer::InitializationToken token =
             GlobalTestSettings.initializer->acquire(controls);
-        return shader->parse(&glslang::DefaultTBuiltInResource, defaultVersion,
-                             isForwardCompatible, controls);
+        return shader->parse(
+                (resources ? resources : &glslang::DefaultTBuiltInResource),
+                defaultVersion, isForwardCompatible, controls);
     }
 
     // Compiles and links the given source |code| of the given shader