1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2016 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 Shader Directive Tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fNegativeShaderDirectiveTests.hpp" 25 26 #include "gluShaderProgram.hpp" 27 28 namespace deqp 29 { 30 namespace gles31 31 { 32 namespace Functional 33 { 34 namespace NegativeTestShared 35 { 36 namespace 37 { 38 39 enum ExpectResult 40 { 41 EXPECT_RESULT_PASS = 0, 42 EXPECT_RESULT_FAIL, 43 44 EXPECT_RESULT_LAST 45 }; 46 47 void verifyProgram(NegativeTestContext& ctx, glu::ProgramSources sources, ExpectResult expect) 48 { 49 DE_ASSERT(expect >= EXPECT_RESULT_PASS && expect < EXPECT_RESULT_LAST); 50 51 tcu::TestLog& log = ctx.getLog(); 52 const glu::ShaderProgram program (ctx.getRenderContext(), sources); 53 bool testFailed = false; 54 std::string message; 55 56 log << program; 57 58 if (expect == EXPECT_RESULT_PASS) 59 { 60 testFailed = !program.getProgramInfo().linkOk; 61 message = "Program did not link."; 62 } 63 else 64 { 65 testFailed = program.getProgramInfo().linkOk; 66 message = "Program was not expected to link."; 67 } 68 69 if (testFailed) 70 { 71 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 72 ctx.fail(message); 73 } 74 } 75 76 void verifyShader(NegativeTestContext& ctx, glu::ShaderType shaderType, std::string shaderSource, ExpectResult expect) 77 { 78 DE_ASSERT(expect >= EXPECT_RESULT_PASS && expect < EXPECT_RESULT_LAST); 79 80 tcu::TestLog& log = ctx.getLog(); 81 bool testFailed = false; 82 const char* const source = shaderSource.c_str(); 83 const int length = (int) shaderSource.size(); 84 glu::Shader shader (ctx.getRenderContext(), shaderType); 85 std::string message; 86 87 shader.setSources(1, &source, &length); 88 shader.compile(); 89 90 log << shader; 91 92 if (expect == EXPECT_RESULT_PASS) 93 { 94 testFailed = !shader.getCompileStatus(); 95 message = "Shader did not compile."; 96 } 97 else 98 { 99 testFailed = shader.getCompileStatus(); 100 message = "Shader was not expected to compile."; 101 } 102 103 if (testFailed) 104 { 105 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage; 106 ctx.fail(message); 107 } 108 } 109 110 void primitive_bounding_box (NegativeTestContext& ctx) 111 { 112 if (ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_CONTROL)) 113 { 114 ctx.beginSection("GL_EXT_primitive_bounding_box features require enabling the extension in 310 es shaders."); 115 std::ostringstream source; 116 source << "#version 310 es\n" 117 "void main()\n" 118 "{\n" 119 " gl_BoundingBoxEXT[0] = vec4(0.0, 0.0, 0.0, 0.0);\n" 120 " gl_BoundingBoxEXT[1] = vec4(1.0, 1.0, 1.0, 1.0);\n" 121 "}\n"; 122 verifyShader(ctx, glu::SHADERTYPE_TESSELLATION_CONTROL, source.str(), EXPECT_RESULT_FAIL); 123 ctx.endSection(); 124 } 125 126 if (contextSupports(ctx.getRenderContext().getType() , glu::ApiType::es(3, 2))) 127 { 128 ctx.beginSection("gl_BoundingBox does not require the OES/EXT suffix in a 320 es shader."); 129 const std::string source = "#version 320 es\n" 130 "layout(vertices = 3) out;\n" 131 "void main()\n" 132 "{\n" 133 " gl_BoundingBox[0] = vec4(0.0, 0.0, 0.0, 0.0);\n" 134 " gl_BoundingBox[1] = vec4(0.0, 0.0, 0.0, 0.0);\n" 135 "}\n"; 136 verifyShader(ctx, glu::SHADERTYPE_TESSELLATION_CONTROL, source, EXPECT_RESULT_PASS); 137 ctx.endSection(); 138 } 139 } 140 141 void blend_equation_advanced (NegativeTestContext& ctx) 142 { 143 static const char* const s_qualifiers[] = 144 { 145 "blend_support_multiply", 146 "blend_support_screen", 147 "blend_support_overlay", 148 "blend_support_darken", 149 "blend_support_lighten", 150 "blend_support_colordodge", 151 "blend_support_colorburn", 152 "blend_support_hardlight", 153 "blend_support_softlight", 154 "blend_support_difference", 155 "blend_support_exclusion", 156 "blend_support_hsl_hue", 157 "blend_support_hsl_saturation", 158 "blend_support_hsl_color", 159 "blend_support_hsl_luminosity", 160 }; 161 162 ctx.beginSection("GL_KHR_blend_equation_advanced features require enabling the extension in 310 es shaders."); 163 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_qualifiers); ++ndx) 164 { 165 std::ostringstream source; 166 source << "#version 310 es\n" 167 "layout(" << s_qualifiers[ndx] << ") out;\n" 168 "void main()\n" 169 "{\n" 170 "}\n"; 171 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 172 } 173 ctx.endSection(); 174 } 175 176 void sample_variables (NegativeTestContext& ctx) 177 { 178 TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType() , glu::ApiType::es(3, 2)), "Test requires a context version 3.2 or higher."); 179 180 static const char* const s_tests[] = 181 { 182 "int sampleId = gl_SampleID;", 183 "vec2 samplePos = gl_SamplePosition;", 184 "int sampleMaskIn0 = gl_SampleMaskIn[0];", 185 "int sampleMask0 = gl_SampleMask[0];", 186 "int numSamples = gl_NumSamples;", 187 }; 188 189 ctx.beginSection("GL_OES_sample_variables features require enabling the extension in 310 es shaders."); 190 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_tests); ++ndx) 191 { 192 std::ostringstream source; 193 source << "#version 310 es\n" 194 "precision mediump float;\n" 195 "void main()\n" 196 "{\n" 197 " " << s_tests[ndx] << "\n" 198 "}\n"; 199 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 200 } 201 ctx.endSection(); 202 } 203 204 void shader_image_atomic (NegativeTestContext& ctx) 205 { 206 static const char* const s_tests[] = 207 { 208 "imageAtomicAdd(u_image, ivec2(1, 1), 1u);", 209 "imageAtomicMin(u_image, ivec2(1, 1), 1u);", 210 "imageAtomicMax(u_image, ivec2(1, 1), 1u);", 211 "imageAtomicAnd(u_image, ivec2(1, 1), 1u);", 212 "imageAtomicOr(u_image, ivec2(1, 1), 1u);", 213 "imageAtomicXor(u_image, ivec2(1, 1), 1u);", 214 "imageAtomicExchange(u_image, ivec2(1, 1), 1u);", 215 "imageAtomicCompSwap(u_image, ivec2(1, 1), 1u, 1u);", 216 }; 217 218 ctx.beginSection("GL_OES_shader_image_atomic features require enabling the extension in 310 es shaders."); 219 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_tests); ++ndx) 220 { 221 std::ostringstream source; 222 source << "#version 310 es\n" 223 "layout(binding=0, r32ui) coherent uniform highp uimage2D u_image;\n" 224 "precision mediump float;\n" 225 "void main()\n" 226 "{\n" 227 " " << s_tests[ndx] << "\n" 228 "}\n"; 229 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 230 } 231 ctx.endSection(); 232 } 233 234 void shader_multisample_interpolation (NegativeTestContext& ctx) 235 { 236 static const char* const s_sampleTests[] = 237 { 238 "sample in highp float v_var;", 239 "sample out highp float v_var;" 240 }; 241 242 static const char* const s_interpolateAtTests[] = 243 { 244 "interpolateAtCentroid(interpolant);", 245 "interpolateAtSample(interpolant, 1);", 246 "interpolateAtOffset(interpolant, vec2(1.0, 0.0));" 247 }; 248 249 ctx.beginSection("GL_OES_shader_multisample_interpolation features require enabling the extension in 310 es shaders."); 250 ctx.beginSection("Test sample in/out qualifiers."); 251 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_sampleTests); ++ndx) 252 { 253 std::ostringstream source; 254 source << "#version 310 es\n" 255 " " << s_sampleTests[ndx] << "\n" 256 "precision mediump float;\n" 257 "void main()\n" 258 "{\n" 259 "}\n"; 260 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 261 } 262 ctx.endSection(); 263 264 ctx.beginSection("Test interpolateAt* functions."); 265 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_sampleTests); ++ndx) 266 { 267 std::ostringstream source; 268 source << "#version 310 es\n" 269 "in mediump float interpolant;\n" 270 "precision mediump float;\n" 271 "void main()\n" 272 "{\n" 273 " " << s_interpolateAtTests[ndx] << "\n" 274 "}\n"; 275 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 276 } 277 ctx.endSection(); 278 ctx.endSection(); 279 } 280 281 void texture_storage_multisample_2d_array (NegativeTestContext& ctx) 282 { 283 static const char* const s_samplerTypeTests[] = 284 { 285 "uniform mediump sampler2DMSArray u_sampler;", 286 "uniform mediump isampler2DMSArray u_sampler;", 287 "uniform mediump usampler2DMSArray u_sampler;", 288 }; 289 290 ctx.beginSection("GL_OES_texture_storage_multisample_2d_array features require enabling the extension in 310 es shaders."); 291 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_samplerTypeTests); ++ndx) 292 { 293 std::ostringstream source; 294 source << "#version 310 es\n" 295 " " << s_samplerTypeTests[ndx] << "\n" 296 "precision mediump float;\n" 297 "void main()\n" 298 "{\n" 299 "}\n"; 300 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 301 } 302 ctx.endSection(); 303 } 304 305 void geometry_shader (NegativeTestContext& ctx) 306 { 307 if (ctx.isShaderSupported(glu::SHADERTYPE_GEOMETRY)) 308 { 309 const std::string simpleVtxFrag = "#version 310 es\n" 310 "void main()\n" 311 "{\n" 312 "}\n"; 313 const std::string geometry = "#version 310 es\n" 314 "layout(points, invocations = 1) in;\n" 315 "layout(points, max_vertices = 3) out;\n" 316 "precision mediump float;\n" 317 "void main()\n" 318 "{\n" 319 " EmitVertex();\n" 320 " EndPrimitive();\n" 321 "}\n"; 322 ctx.beginSection("GL_EXT_geometry_shader features require enabling the extension in 310 es shaders."); 323 verifyProgram(ctx, glu::ProgramSources() << glu::VertexSource(simpleVtxFrag) << glu::GeometrySource(geometry) << glu::FragmentSource(simpleVtxFrag), EXPECT_RESULT_FAIL); 324 ctx.endSection(); 325 } 326 } 327 328 void gpu_shader_5 (NegativeTestContext& ctx) 329 { 330 ctx.beginSection("GL_EXT_gpu_shader5 features require enabling the extension in 310 es shaders."); 331 ctx.beginSection("Testing the precise qualifier."); 332 { 333 std::ostringstream source; 334 source << "#version 310 es\n" 335 "void main()\n" 336 "{\n" 337 " int low = 0;\n" 338 " int high = 10;\n" 339 " precise int middle = low + ((high - low) / 2);\n" 340 "}\n"; 341 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 342 } 343 ctx.endSection(); 344 345 ctx.beginSection("Testing fused multiply-add."); 346 { 347 std::ostringstream source; 348 source << "#version 310 es\n" 349 "in mediump float v_var;" 350 "void main()\n" 351 "{\n" 352 " float fmaResult = fma(v_var, v_var, v_var);" 353 "}\n"; 354 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 355 } 356 ctx.endSection(); 357 358 ctx.beginSection("Testing textureGatherOffsets."); 359 { 360 std::ostringstream source; 361 source << "#version 310 es\n" 362 "uniform mediump sampler2D u_tex;\n" 363 "void main()\n" 364 "{\n" 365 " highp vec2 coords = vec2(0.0, 1.0);\n" 366 " const ivec2 offsets[4] = ivec2[](ivec2(0,0), ivec2(1, 0), ivec2(0, 1), ivec2(1, 1));\n" 367 " textureGatherOffsets(u_tex, coords, offsets);\n" 368 "}\n"; 369 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 370 } 371 ctx.endSection(); 372 373 ctx.endSection(); 374 } 375 376 void shader_io_blocks (NegativeTestContext& ctx) 377 { 378 ctx.beginSection("GL_EXT_shader_io_blocks features require enabling the extension in 310 es shaders."); 379 { 380 std::ostringstream source; 381 source << "#version 310 es\n" 382 "in Data\n" 383 "{\n" 384 " mediump vec3 a;\n" 385 "} data;\n" 386 "void main()\n" 387 "{\n" 388 "}\n"; 389 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 390 } 391 ctx.endSection(); 392 } 393 394 void tessellation_shader (NegativeTestContext& ctx) 395 { 396 if (ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_CONTROL)) 397 { 398 const std::string simpleVtxFrag = "#version 310 es\n" 399 "void main()\n" 400 "{\n" 401 "}\n"; 402 const std::string tessControl = "#version 310 es\n" 403 "layout(vertices = 3) out;\n" 404 "void main()\n" 405 "{\n" 406 "}\n"; 407 const std::string tessEvaluation = "#version 310 es\n" 408 "layout(triangles, equal_spacing, cw) in;\n" 409 "void main()\n" 410 "{\n" 411 "}\n"; 412 ctx.beginSection("GL_EXT_tessellation_shader features require enabling the extension in 310 es shaders."); 413 glu::ProgramSources sources; 414 sources << glu::VertexSource(simpleVtxFrag) 415 << glu::TessellationControlSource(tessControl) 416 << glu::TessellationEvaluationSource(tessEvaluation) 417 << glu::FragmentSource(simpleVtxFrag); 418 verifyProgram(ctx, sources, EXPECT_RESULT_FAIL); 419 ctx.endSection(); 420 } 421 } 422 423 void texture_buffer (NegativeTestContext& ctx) 424 { 425 static const char* const s_samplerBufferTypes[] = 426 { 427 "uniform mediump samplerBuffer", 428 "uniform mediump isamplerBuffer", 429 "uniform mediump usamplerBuffer", 430 "layout(rgba32f) uniform mediump writeonly imageBuffer", 431 "layout(rgba32i) uniform mediump writeonly iimageBuffer", 432 "layout(rgba32ui) uniform mediump writeonly uimageBuffer" 433 }; 434 435 ctx.beginSection("GL_EXT_texture_buffer features require enabling the extension in 310 es shaders."); 436 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_samplerBufferTypes); ++ndx) 437 { 438 std::ostringstream source; 439 source << "#version 310 es\n" 440 "" << s_samplerBufferTypes[ndx] << " u_buffer;\n" 441 "void main()\n" 442 "{\n" 443 "}\n"; 444 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 445 } 446 ctx.endSection(); 447 } 448 449 450 void texture_cube_map_array (NegativeTestContext& ctx) 451 { 452 static const char* const s_samplerCubeArrayTypes[] = 453 { 454 "uniform mediump samplerCubeArray", 455 "uniform mediump isamplerCubeArray", 456 "uniform mediump usamplerCubeArray", 457 "uniform mediump samplerCubeArrayShadow", 458 "layout(rgba32f) uniform mediump writeonly imageCubeArray", 459 "layout(rgba32i) uniform mediump writeonly iimageCubeArray", 460 "layout(rgba32ui) uniform mediump writeonly uimageCubeArray" 461 }; 462 463 ctx.beginSection("GL_EXT_texture_cube_map_array features require enabling the extension in 310 es shaders."); 464 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_samplerCubeArrayTypes); ++ndx) 465 { 466 std::ostringstream source; 467 source << "#version 310 es\n" 468 "" << s_samplerCubeArrayTypes[ndx] << " u_cube;\n" 469 "void main()\n" 470 "{\n" 471 "}\n"; 472 verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL); 473 } 474 ctx.endSection(); 475 } 476 477 } // anonymous 478 479 std::vector<FunctionContainer> getNegativeShaderDirectiveTestFunctions (void) 480 { 481 const FunctionContainer funcs[] = 482 { 483 {primitive_bounding_box, "primitive_bounding_box", "GL_EXT_primitive_bounding_box required in 310 es shaders to use AEP features. Version 320 es shaders do not require suffixes." }, 484 {blend_equation_advanced, "blend_equation_advanced", "GL_KHR_blend_equation_advanced is required in 310 es shaders to use AEP features" }, 485 {sample_variables, "sample_variables", "GL_OES_sample_variables is required in 310 es shaders to use AEP features" }, 486 {shader_image_atomic, "shader_image_atomic", "GL_OES_shader_image_atomic is required in 310 es shaders to use AEP features" }, 487 {shader_multisample_interpolation, "shader_multisample_interpolation", "GL_OES_shader_multisample_interpolation is required in 310 es shaders to use AEP features" }, 488 {texture_storage_multisample_2d_array, "texture_storage_multisample_2d_array", "GL_OES_texture_storage_multisample_2d_array is required in 310 es shaders to use AEP features" }, 489 {geometry_shader, "geometry_shader", "GL_EXT_geometry_shader is required in 310 es shaders to use AEP features" }, 490 {gpu_shader_5, "gpu_shader_5", "GL_EXT_gpu_shader5 is required in 310 es shaders to use AEP features" }, 491 {shader_io_blocks, "shader_io_blocks", "GL_EXT_shader_io_blocks is required in 310 es shaders to use AEP features" }, 492 {tessellation_shader, "tessellation_shader", "GL_EXT_tessellation_shader is required in 310 es shaders to use AEP features" }, 493 {texture_buffer, "texture_buffer", "GL_EXT_texture_buffer is required in 310 es shaders to use AEP features" }, 494 {texture_cube_map_array, "texture_cube_map_array", "GL_EXT_texture_cube_map_array is required in 310 es shaders to use AEP features" }, 495 }; 496 497 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs)); 498 } 499 500 } // NegativeTestShared 501 } // Functional 502 } // gles31 503 } // deqp 504
