modules/gles31/functional/es31fNegativeSampleVariablesTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2017 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Negative Sample Variables Tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fNegativeSampleVariablesTests.hpp"
  25 #include "gluShaderProgram.hpp"
  26
  27 namespace deqp
  28 {
  29 namespace gles31
  30 {
  31 namespace Functional
  32 {
  33 namespace NegativeTestShared
  34 {
  35 namespace
  36 {
  37
  38 enum ExpectResult
  39 {
  40         EXPECT_RESULT_PASS = 0,
  41         EXPECT_RESULT_FAIL,
  42         EXPECT_RESULT_LAST
  43 };
  44
  45 void verifyShader (NegativeTestContext& ctx, glu::ShaderType shaderType, std::string shaderSource, ExpectResult expect)
  46 {
  47         DE_ASSERT(expect >= EXPECT_RESULT_PASS && expect < EXPECT_RESULT_LAST);
  48
  49         tcu::TestLog&           log                     = ctx.getLog();
  50         bool                            testFailed      = false;
  51         const char* const       source          = shaderSource.c_str();
  52         const int                       length          = (int) shaderSource.size();
  53         glu::Shader                     shader          (ctx.getRenderContext(), shaderType);
  54         std::string                     message;
  55
  56         shader.setSources(1, &source, &length);
  57         shader.compile();
  58
  59         log << shader;
  60
  61         if (expect == EXPECT_RESULT_PASS)
  62         {
  63                 testFailed = !shader.getCompileStatus();
  64                 message = "Shader did not compile.";
  65         }
  66         else
  67         {
  68                 testFailed = shader.getCompileStatus();
  69                 message = "Shader was not expected to compile.";
  70         }
  71
  72         if (testFailed)
  73         {
  74                 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
  75                 ctx.fail(message);
  76         }
  77 }
  78
  79 std::string getVersionAndExtension (NegativeTestContext& ctx)
  80 {
  81         const bool                              isES32  = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
  82         const glu::GLSLVersion  version = isES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES;
  83
  84         std::string versionAndExtension = glu::getGLSLVersionDeclaration(version);
  85         versionAndExtension += " \n";
  86
  87         if (!isES32)
  88                 versionAndExtension += "#extension GL_OES_sample_variables : require \n";
  89
  90         return versionAndExtension;
  91 }
  92
  93 void checkSupported (NegativeTestContext& ctx)
  94 {
  95         const bool isES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
  96
  97         if (!isES32 && !ctx.isExtensionSupported("GL_OES_sample_variables"))
  98                 TCU_THROW(NotSupportedError, "GL_OES_sample_variables is not supported.");
  99 }
 100
 101 void write_to_read_only_types (NegativeTestContext& ctx)
 102 {
 103         checkSupported(ctx);
 104
 105         std::ostringstream      shader;
 106
 107         struct testConfig
 108         {
 109                 std::string builtInType;
 110                 std::string varyingCheck;
 111         } testConfigs[] =
 112         {
 113                 {"gl_SampleID",                 "       lowp int writeValue = 1; \n     gl_SampleID = writeValue; \n"},
 114                 {"gl_SamplePosition",   "       mediump vec2 writeValue = vec2(1.0f, 1.0f); \n  gl_SamplePosition = writeValue; \n"},
 115                 {"gl_SampleMaskIn",             "       lowp int writeValue = 1; \n     gl_SampleMaskIn[0] = writeValue; \n"}
 116         };
 117
 118         for (int idx = 0; idx < DE_LENGTH_OF_ARRAY(testConfigs); idx++)
 119         {
 120                 shader.str("");
 121                 shader
 122                         << getVersionAndExtension(ctx)
 123                         << "layout (location = 0) out mediump vec4 fs_color; \n"
 124                         << "void main() \n"
 125                         << "{ \n"
 126                         <<              testConfigs[idx].varyingCheck
 127                         << "    fs_color = vec4(1.0f, 0.0f, 0.0f, 1.0f); \n"
 128                         << "} \n";
 129
 130                 ctx.beginSection("OES_sample_variables: trying to write to built-in read-only variable" + testConfigs[idx].builtInType);
 131                 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, shader.str(), EXPECT_RESULT_FAIL);
 132                 ctx.endSection();
 133         }
 134 }
 135
 136 void access_built_in_types_inside_other_shaders (NegativeTestContext& ctx)
 137 {
 138         checkSupported(ctx);
 139
 140         if ((!ctx.isExtensionSupported("GL_EXT_tessellation_shader") && !ctx.isExtensionSupported("GL_OES_tessellation_shader")) ||
 141                 (!ctx.isExtensionSupported("GL_EXT_geometry_shader") && !ctx.isExtensionSupported("GL_OES_geometry_shader")))
 142         {
 143                 TCU_THROW(NotSupportedError, "tessellation and geometry shader extensions not supported");
 144         }
 145
 146         std::ostringstream      shader;
 147
 148         struct testConfig
 149         {
 150                 std::string builtInType;
 151                 std::string varyingCheck;
 152         } testConfigs[] =
 153         {
 154                 {"gl_SampleID",                 "       lowp int writeValue = 1; \n     gl_SampleID = writeValue; \n"},
 155                 {"gl_SamplePosition",   "       mediump vec2 writeValue = vec2(1.0f, 1.0f); \n  gl_SamplePosition = writeValue; \n"},
 156                 {"gl_SampleMaskIn",             "       lowp int writeValue = 1; \n     gl_SampleMaskIn[0] = writeValue; \n"},
 157                 {"gl_SampleMask",               "       highp int readValue = gl_SampleMask[0]; \n"},
 158         };
 159
 160         for (int idx = 0; idx < DE_LENGTH_OF_ARRAY(testConfigs); idx++)
 161         {
 162                 shader.str("");
 163                 shader
 164                         << getVersionAndExtension(ctx)
 165                         << "void main () \n"
 166                         << "{ \n"
 167                         <<              testConfigs[idx].varyingCheck
 168                         << "    gl_Position = vec4(1.0f, 0.0f, 0.0f , 1.0f); \n"
 169                         << "} \n";
 170
 171                 ctx.beginSection("OES_sample_variables: trying to use fragment shader built-in sampler variable " + testConfigs[idx].builtInType + " inside vertex shader");
 172                 verifyShader(ctx, glu::SHADERTYPE_VERTEX, shader.str(), EXPECT_RESULT_FAIL);
 173                 ctx.endSection();
 174         }
 175
 176         for (int idx = 0; idx < DE_LENGTH_OF_ARRAY(testConfigs); idx++)
 177         {
 178                 shader.str("");
 179                 shader
 180                         << getVersionAndExtension(ctx)
 181                         << "layout (vertices = 3) out; \n"
 182                         << "void main () \n"
 183                         << "{ \n"
 184                         <<              testConfigs[idx].varyingCheck
 185                         << "} \n";
 186
 187                 ctx.beginSection("OES_sample_variables: trying to use fragment shader built-in sampler variable " + testConfigs[idx].builtInType + " inside tessellation control shader");
 188                 verifyShader(ctx, glu::SHADERTYPE_TESSELLATION_CONTROL, shader.str(), EXPECT_RESULT_FAIL);
 189                 ctx.endSection();
 190         }
 191
 192         for (int idx = 0; idx < DE_LENGTH_OF_ARRAY(testConfigs); idx++)
 193         {
 194                 shader.str("");
 195                 shader
 196                         << getVersionAndExtension(ctx)
 197                         << "layout (triangles, equal_spacing, ccw) in; \n"
 198                         << "void main () \n"
 199                         << "{ \n"
 200                         <<              testConfigs[idx].varyingCheck
 201                         << "} \n";
 202
 203                 ctx.beginSection("OES_sample_variables: trying to use fragment shader built-in sampler variable " + testConfigs[idx].builtInType + " inside tessellation evaluation shader");
 204                 verifyShader(ctx, glu::SHADERTYPE_TESSELLATION_EVALUATION, shader.str(), EXPECT_RESULT_FAIL);
 205                 ctx.endSection();
 206         }
 207
 208         for (int idx = 0; idx < DE_LENGTH_OF_ARRAY(testConfigs); idx++)
 209         {
 210                 shader.str("");
 211                 shader
 212                         << getVersionAndExtension(ctx)
 213                         << "layout (triangles) in; \n"
 214                         << "layout (triangle_strip, max_vertices = 32) out; \n"
 215                         << "void main () \n"
 216                         << "{ \n"
 217                         <<              testConfigs[idx].varyingCheck
 218                         << "} \n";
 219
 220                 ctx.beginSection("OES_sample_variables: trying to use fragment shader built-in sampler variable " + testConfigs[idx].builtInType + " inside geometry shader");
 221                 verifyShader(ctx, glu::SHADERTYPE_GEOMETRY, shader.str(), EXPECT_RESULT_FAIL);
 222                 ctx.endSection();
 223         }
 224 }
 225
 226 void index_outside_sample_mask_range (NegativeTestContext& ctx)
 227 {
 228         checkSupported(ctx);
 229
 230         std::ostringstream      shader;
 231         const int                       MAX_TYPES       = 2;
 232         const int                       MAX_INDEXES = 2;
 233
 234         struct testConfig
 235         {
 236                 std::string builtInType[MAX_TYPES];
 237                 std::string invalidIndex[MAX_INDEXES];
 238         } testConfigs =
 239         {
 240                 {
 241                         "gl_SampleMask",
 242                         "gl_SampleMaskIn"
 243                 },
 244                 {
 245                         "       const highp int invalidIndex = (gl_MaxSamples + 31) / 32; \n",
 246                         "       const highp int invalidIndex = -1; \n"
 247                 }
 248         };
 249
 250         for (int typeIdx = 0; typeIdx < MAX_TYPES; typeIdx++)
 251         {
 252                 for (int invalidIdx = 0; invalidIdx < MAX_INDEXES; invalidIdx++)
 253                 {
 254                         shader.str("");
 255                         shader
 256                                 << getVersionAndExtension(ctx)
 257                                 << "layout (location = 0) out mediump vec4 fs_color; \n"
 258                                 << "void main() \n"
 259                                 << "{ \n"
 260                                 <<              testConfigs.invalidIndex[invalidIdx]
 261                                 << "    highp int invalidValue = " << testConfigs.builtInType[typeIdx] << "[invalidIndex]; \n"
 262                                 << "    fs_color = vec4(1.0f, 0.0f, 0.0f, 1.0f); \n"
 263                                 << "} \n";
 264
 265                         ctx.beginSection("OES_sample_variables: using constant integral expression outside of " + testConfigs.builtInType[typeIdx] + " bounds");
 266                         verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, shader.str(), EXPECT_RESULT_FAIL);
 267                         ctx.endSection();
 268                 }
 269         }
 270 }
 271
 272 void access_built_in_types_without_extension (NegativeTestContext& ctx)
 273 {
 274         checkSupported(ctx);
 275
 276         std::ostringstream      shader;
 277
 278         struct testConfig
 279         {
 280                 std::string builtInType;
 281                 std::string varyingCheck;
 282         } testConfigs[] =
 283         {
 284                 {"gl_SampleID",                 "       lowp int writeValue = 1; \n     gl_SampleID = writeValue; \n"},
 285                 {"gl_SamplePosition",   "       mediump vec2 writeValue = vec2(1.0f, 1.0f); \n  gl_SamplePosition = writeValue; \n"},
 286                 {"gl_SampleMaskIn",             "       lowp int writeValue = 1; \n     gl_SampleMaskIn[0] = writeValue; \n"},
 287                 {"gl_SampleMask",               "       highp int readValue = gl_SampleMask[0]; \n"},
 288         };
 289
 290         for (int idx = 0; idx < DE_LENGTH_OF_ARRAY(testConfigs); idx++)
 291         {
 292                 shader.str("");
 293                 shader
 294                         << "#version 310 es \n"
 295                         << "layout (location = 0) out mediump vec4 fs_color; \n"
 296                         << "void main() \n"
 297                         << "{ \n"
 298                         <<              testConfigs[idx].varyingCheck
 299                         << "    fs_color = vec4(1.0f, 0.0f, 0.0f, 1.0f); \n"
 300                         << "} \n";
 301
 302                 ctx.beginSection("OES_sample_variables: accessing built-in type " + testConfigs[idx].builtInType + " in shader version 310 ES without required extension");
 303                 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, shader.str(), EXPECT_RESULT_FAIL);
 304                 ctx.endSection();
 305         }
 306 }
 307
 308 void redeclare_built_in_types (NegativeTestContext& ctx)
 309 {
 310         checkSupported(ctx);
 311
 312         std::ostringstream      shader;
 313         std::ostringstream      testName;
 314
 315         const char* const testConfigs[] =
 316         {
 317                 "gl_SampleID",
 318                 "gl_SamplePosition",
 319                 "gl_SampleMaskIn",
 320                 "gl_SampleMask",
 321         };
 322
 323         for (int idx = 0; idx < DE_LENGTH_OF_ARRAY(testConfigs); idx++)
 324         {
 325                 shader.str("");
 326                 shader
 327                         << getVersionAndExtension(ctx)
 328                         << "layout (location = 0) out mediump vec4 fs_color; \n"
 329                         << "uniform lowp int " << testConfigs[idx] << "; \n"
 330                         << "void main() \n"
 331                         << "{ \n"
 332                         << "    if (" << testConfigs[idx] << " == 0) \n"
 333                         << "            fs_color = vec4(1.0f, 0.0f, 0.0f, 1.0f); \n"
 334                         << "    else \n"
 335                         << "            fs_color = vec4(0.0f, 1.0f, 0.0f, 1.0f); \n"
 336                         << "} \n";
 337
 338                 testName.str("");
 339                 testName << "OES_sample_variables: redeclare built-in type " << testConfigs[idx];
 340                 ctx.beginSection(testName.str());
 341                 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, shader.str(), EXPECT_RESULT_FAIL);
 342                 ctx.endSection();
 343         }
 344 }
 345
 346 } // anonymous
 347
 348 std::vector<FunctionContainer> getNegativeSampleVariablesTestFunctions (void)
 349 {
 350         const FunctionContainer funcs[] =
 351         {
 352                 {write_to_read_only_types,                                              "write_to_read_only_types",                                             "tests trying writing to read-only built-in sample variables"},
 353                 {access_built_in_types_inside_other_shaders,    "access_built_in_types_inside_other_shaders",   "Tests try to access fragment shader sample variables in other shaders"},
 354                 {index_outside_sample_mask_range,                               "index_outside_sample_mask_range",                              "tests try to index into built-in sample array types out of bounds"},
 355                 {access_built_in_types_without_extension,               "access_built_in_types_without_extension",              "tests try to access built-in sample types without the correct extension using version 310 es"},
 356                 {redeclare_built_in_types,                                              "redeclare_built_in_types",                                             "Tests try to redeclare built-in sample types"},
 357         };
 358
 359         return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
 360 }
 361
 362 } // NegativeTestShared
 363 } // Functional
 364 } // gles31
 365 } // deqp