1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2014-2016 The Khronos Group Inc. 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 22 */ /*-------------------------------------------------------------------*/ 23 24 #include "es31cArrayOfArraysTests.hpp" 25 #include "gluContextInfo.hpp" 26 #include "gluDefs.hpp" 27 #include "gluRenderContext.hpp" 28 #include "glwFunctions.hpp" 29 #include "tcuTestLog.hpp" 30 31 #include <algorithm> 32 #include <cassert> 33 #include <cstdio> 34 #include <string> 35 using std::string; 36 37 /* Selects if debug output is enabled */ 38 #define IS_DEBUG 0 39 #define IS_DEBUG_DUMP_ALL_SHADERS 0 40 41 /* Selects if workaround in ExpressionsInvalid2 test is enabled */ 42 #define WRKARD_EXPRESSIONSINVALID2 0 43 44 #if IS_DEBUG 45 #include "tcuTestLog.hpp" 46 #endif 47 48 namespace glcts 49 { 50 namespace ArraysOfArrays 51 { 52 namespace Interface 53 { 54 /* Sets limits on number of dimensions. Value 8 comes from ogirinal "ES" implementation. 55 * Explanation was as follows: 56 * 57 * "The current specifations allow up to 8 array dimensions." 58 */ 59 const size_t ES::MAX_ARRAY_DIMENSIONS = 8; 60 const size_t GL::MAX_ARRAY_DIMENSIONS = 8; 61 62 /* API specific shader parts */ 63 const char* ES::shader_version_gpu5 = 64 "#version 310 es\n#extension GL_EXT_gpu_shader5 : require\nprecision mediump float;\n\n"; 65 const char* ES::shader_version = "#version 310 es\nprecision mediump float;\n\n"; 66 67 const char* GL::shader_version_gpu5 = "#version 430 core\n\n"; 68 const char* GL::shader_version = "#version 430 core\n\n"; 69 } /* namespace Interface */ 70 71 /* Dummy fragment shader source code. 72 * Used when testing the vertex shader. */ 73 const std::string default_fragment_shader_source = "//default fragment shader\n" 74 "out vec4 color;\n" 75 "void main()\n" 76 "{\n" 77 " color = vec4(1.0);\n" 78 "}\n"; 79 80 /* Dummy vertex shader source code. 81 * Used when testing the fragment shader. */ 82 const std::string default_vertex_shader_source = "//default vertex shader\n" 83 "\n" 84 "void main()\n" 85 "{\n" 86 " gl_Position = vec4(0.0,0.0,0.0,1.0);\n" 87 "}\n"; 88 89 /* Dummy geometry shader source code. 90 * Used when testing the other shaders. */ 91 const std::string default_geometry_shader_source = "//default geometry\n" 92 "\n" 93 "void main()\n" 94 "{\n" 95 " gl_Position = vec4(-1, -1, 0, 1);\n" 96 " EmitVertex();\n" 97 " gl_Position = vec4(-1, 1, 0, 1);\n" 98 " EmitVertex();\n" 99 " gl_Position = vec4(1, -1, 0, 1);\n" 100 " EmitVertex();\n" 101 " gl_Position = vec4(1, 1, 0, 1);\n" 102 " EmitVertex();\n" 103 "}\n"; 104 105 /* Dummy tesselation control shader source code. 106 * Used when testing the other shaders. */ 107 const std::string default_tc_shader_source = "//default tcs\n" 108 "\n" 109 "void main()\n" 110 "{\n" 111 " gl_TessLevelOuter[0] = 1.0;\n" 112 " gl_TessLevelOuter[1] = 1.0;\n" 113 " gl_TessLevelOuter[2] = 1.0;\n" 114 " gl_TessLevelOuter[3] = 1.0;\n" 115 " gl_TessLevelInner[0] = 1.0;\n" 116 " gl_TessLevelInner[1] = 1.0;\n" 117 "}\n"; 118 119 /* Dummy tesselation evaluation shader source code. 120 * Used when testing the other shaders. */ 121 const std::string default_te_shader_source = "//default tes\n" 122 "\n" 123 "void main()\n" 124 "{\n" 125 "}\n"; 126 127 /* Pass-through shaders source code. Used when testing other stage. */ 128 const std::string pass_fragment_shader_source = "//pass fragment shader\n" 129 "in float fs_result;\n" 130 "out vec4 color;\n" 131 "\n" 132 "void main()\n" 133 "{\n" 134 " color = vec4(fs_result);\n" 135 "}\n"; 136 137 const std::string pass_geometry_shader_source = "//pass geometry\n" 138 "in float gs_result[];\n" 139 "out float fs_result;\n" 140 "\n" 141 "void main()\n" 142 "{\n" 143 " gl_Position = vec4(-1, -1, 0, 1);\n" 144 " fs_result = gs_result[0];\n" 145 " EmitVertex();\n" 146 " gl_Position = vec4(-1, 1, 0, 1);\n" 147 " fs_result = gs_result[0];\n" 148 " EmitVertex();\n" 149 " gl_Position = vec4(1, -1, 0, 1);\n" 150 " fs_result = gs_result[0];\n" 151 " EmitVertex();\n" 152 " gl_Position = vec4(1, 1, 0, 1);\n" 153 " fs_result = gs_result[0];\n" 154 " EmitVertex();\n" 155 "}\n"; 156 157 const std::string pass_te_shader_source = "//pass tes\n" 158 "in float tcs_result[];\n" 159 "out float fs_result;\n" 160 "\n" 161 "void main()\n" 162 "{\n" 163 " fs_result = tcs_result[0];\n" 164 "}\n"; 165 166 /* Empty string */ 167 static const std::string empty_string = ""; 168 169 /* Beginning of a shader source code. */ 170 const std::string shader_start = "void main()\n" 171 "{\n"; 172 173 /* End of a shader source code. */ 174 const std::string shader_end = "}\n"; 175 176 /* Emit full screen quad from GS */ 177 const std::string emit_quad = " gl_Position = vec4(-1, -1, 0, 1);\n" 178 " EmitVertex();\n" 179 " gl_Position = vec4(-1, 1, 0, 1);\n" 180 " EmitVertex();\n" 181 " gl_Position = vec4(1, -1, 0, 1);\n" 182 " EmitVertex();\n" 183 " gl_Position = vec4(1, 1, 0, 1);\n" 184 " EmitVertex();\n"; 185 186 /* Set tesselation levels */ 187 const std::string set_tesseation = " gl_TessLevelOuter[0] = 1.0;\n" 188 " gl_TessLevelOuter[1] = 1.0;\n" 189 " gl_TessLevelOuter[2] = 1.0;\n" 190 " gl_TessLevelOuter[3] = 1.0;\n" 191 " gl_TessLevelInner[0] = 1.0;\n" 192 " gl_TessLevelInner[1] = 1.0;\n"; 193 194 /* Input and output data type modifiers. */ 195 const std::string in_out_type_modifiers[] = { "in", "out", "uniform" }; 196 197 /* Types and appropriate initialisers, used throughout these tests */ 198 const var_descriptor var_descriptors[] = { 199 { "bool", "", "true", "false", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 200 { "int", "", "1", "0", "0", "int", "", "iterator", "1", "N/A", "N/A" }, 201 { "uint", "", "1u", "0u", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 202 { "float", "", "1.0", "0.0", "0.0", "float", "", "iterator", "1.0", "N/A", "N/A" }, 203 { "vec2", "", "vec2(1.0)", "vec2(0.0)", "0.0", "float", "[0]", "vec2(iterator)", "vec2(1.0)", "N/A", "N/A" }, 204 { "vec3", "", "vec3(1.0)", "vec3(0.0)", "0.0", "float", "[0]", "vec3(iterator)", "vec3(1.0)", "N/A", "N/A" }, 205 { "vec4", "", "vec4(1.0)", "vec4(0.0)", "0.0", "float", "[0]", "vec4(iterator)", "vec4(1.0)", "N/A", "N/A" }, 206 { "bvec2", "", "bvec2(1)", "bvec2(0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 207 { "bvec3", "", "bvec3(1)", "bvec3(0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 208 { "bvec4", "", "bvec4(1)", "bvec4(0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 209 { "ivec2", "", "ivec2(1)", "ivec2(0)", "0", "int", "[0]", "ivec2(iterator)", "ivec2(1)", "N/A", "N/A" }, 210 { "ivec3", "", "ivec3(1)", "ivec3(0)", "0", "int", "[0]", "ivec3(iterator)", "ivec3(1)", "N/A", "N/A" }, 211 { "ivec4", "", "ivec4(1)", "ivec4(0)", "0", "int", "[0]", "ivec4(iterator)", "ivec4(1)", "N/A", "N/A" }, 212 { "uvec2", "", "uvec2(1u)", "uvec2(0u)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 213 { "uvec3", "", "uvec3(1u)", "uvec3(0u)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 214 { "uvec4", "", "uvec4(1u)", "uvec4(0u)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 215 { "mat2", "", "mat2(1.0)", "mat2(0.0)", "0.0", "float", "[0][0]", "mat2(iterator)", "mat2(1.0)", "N/A", "N/A" }, 216 { "mat3", "", "mat3(1.0)", "mat3(0.0)", "0.0", "float", "[0][0]", "mat3(iterator)", "mat3(1.0)", "N/A", "N/A" }, 217 { "mat4", "", "mat4(1.0)", "mat4(0.0)", "0.0", "float", "[0][0]", "mat4(iterator)", "mat4(1.0)", "N/A", "N/A" }, 218 { "mat2x2", "", "mat2x2(1.0)", "mat2x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 219 { "mat2x3", "", "mat2x3(1.0)", "mat2x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 220 { "mat2x4", "", "mat2x4(1.0)", "mat2x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 221 { "mat3x2", "", "mat3x2(1.0)", "mat3x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 222 { "mat3x3", "", "mat3x3(1.0)", "mat3x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 223 { "mat3x4", "", "mat3x4(1.0)", "mat3x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 224 { "mat4x2", "", "mat4x2(1.0)", "mat4x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 225 { "mat4x3", "", "mat4x3(1.0)", "mat4x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 226 { "mat4x4", "", "mat4x4(1.0)", "mat4x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 227 { "imageBuffer", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 228 { "iimageBuffer", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 229 { "uimageBuffer", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 230 { "samplerBuffer", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 231 { "isamplerBuffer", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 232 { "usamplerBuffer", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 233 { "sampler2D", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec2(0.0)", "vec4" }, 234 { "sampler3D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "vec4" }, 235 { "samplerCube", "", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "vec4" }, 236 { 237 "samplerCubeShadow", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec4(0.0)", "float", 238 }, 239 { "sampler2DShadow", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "float" }, 240 { "sampler2DArray", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "vec4" }, 241 { "sampler2DArrayShadow", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec4(0.0)", "float" }, 242 { "isampler2D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec2(0.0)", "ivec4" }, 243 { "isampler3D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "ivec4" }, 244 { "isamplerCube", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "ivec4" }, 245 { "isampler2DArray", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "ivec4" }, 246 { "usampler2D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec2(0.0)", "uvec4" }, 247 { "usampler3D", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "uvec4" }, 248 { "usamplerCube", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "uvec4" }, 249 { "usampler2DArray", "lowp", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "vec3(0.0)", "uvec4" }, 250 }; 251 252 const var_descriptor var_double_descriptors[] = { 253 { "double", "", "1.0", "0.0", "0.0", "double", "", "iterator", "1.0", "N/A", "N/A" }, 254 { "dmat2", "", "dmat2(1.0)", "dmat2(0.0)", "0.0", "double", "[0][0]", "dmat2(iterator)", "dmat2(1.0)", "N/A", 255 "N/A" }, 256 { "dmat3", "", "dmat3(1.0)", "dmat3(0.0)", "0.0", "double", "[0][0]", "dmat3(iterator)", "dmat3(1.0)", "N/A", 257 "N/A" }, 258 { "dmat4", "", "dmat4(1.0)", "dmat4(0.0)", "0.0", "double", "[0][0]", "dmat4(iterator)", "dmat4(1.0)", "N/A", 259 "N/A" }, 260 { "dmat2x2", "", "dmat2x2(1.0)", "dmat2x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 261 { "dmat2x3", "", "dmat2x3(1.0)", "dmat2x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 262 { "dmat2x4", "", "dmat2x4(1.0)", "dmat2x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 263 { "dmat3x2", "", "dmat3x2(1.0)", "dmat3x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 264 { "dmat3x3", "", "dmat3x3(1.0)", "dmat3x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 265 { "dmat3x4", "", "dmat3x4(1.0)", "dmat3x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 266 { "dmat4x2", "", "dmat4x2(1.0)", "dmat4x2(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 267 { "dmat4x3", "", "dmat4x3(1.0)", "dmat4x3(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 268 { "dmat4x4", "", "dmat4x4(1.0)", "dmat4x4(0.0)", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A" }, 269 }; 270 271 _supported_variable_types_map supported_variable_types_map; 272 273 /** List of all supported variable types for es. */ 274 const test_var_type var_types_es[] = { 275 VAR_TYPE_BOOL, VAR_TYPE_INT, VAR_TYPE_UINT, VAR_TYPE_FLOAT, VAR_TYPE_VEC2, VAR_TYPE_VEC3, 276 VAR_TYPE_VEC4, VAR_TYPE_BVEC2, VAR_TYPE_BVEC3, VAR_TYPE_BVEC4, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, 277 VAR_TYPE_IVEC4, VAR_TYPE_UVEC2, VAR_TYPE_UVEC3, VAR_TYPE_UVEC4, VAR_TYPE_MAT2, VAR_TYPE_MAT3, 278 VAR_TYPE_MAT4, VAR_TYPE_MAT2X2, VAR_TYPE_MAT2X3, VAR_TYPE_MAT2X4, VAR_TYPE_MAT3X2, VAR_TYPE_MAT3X3, 279 VAR_TYPE_MAT3X4, VAR_TYPE_MAT4X2, VAR_TYPE_MAT4X3, VAR_TYPE_MAT4X4, 280 }; 281 282 const test_var_type* Interface::ES::var_types = var_types_es; 283 const size_t Interface::ES::n_var_types = sizeof(var_types_es) / sizeof(var_types_es[0]); 284 285 /** List of all supported variable types for gl. */ 286 static const glcts::test_var_type var_types_gl[] = { 287 VAR_TYPE_BOOL, VAR_TYPE_INT, VAR_TYPE_UINT, VAR_TYPE_FLOAT, VAR_TYPE_VEC2, VAR_TYPE_VEC3, 288 VAR_TYPE_VEC4, VAR_TYPE_BVEC2, VAR_TYPE_BVEC3, VAR_TYPE_BVEC4, VAR_TYPE_IVEC2, VAR_TYPE_IVEC3, 289 VAR_TYPE_IVEC4, VAR_TYPE_UVEC2, VAR_TYPE_UVEC3, VAR_TYPE_UVEC4, VAR_TYPE_MAT2, VAR_TYPE_MAT3, 290 VAR_TYPE_MAT4, VAR_TYPE_MAT2X2, VAR_TYPE_MAT2X3, VAR_TYPE_MAT2X4, VAR_TYPE_MAT3X2, VAR_TYPE_MAT3X3, 291 VAR_TYPE_MAT3X4, VAR_TYPE_MAT4X2, VAR_TYPE_MAT4X3, VAR_TYPE_MAT4X4, VAR_TYPE_DOUBLE, VAR_TYPE_DMAT2, 292 VAR_TYPE_DMAT3, VAR_TYPE_DMAT4, VAR_TYPE_DMAT2X2, VAR_TYPE_DMAT2X3, VAR_TYPE_DMAT2X4, VAR_TYPE_DMAT3X2, 293 VAR_TYPE_DMAT3X3, VAR_TYPE_DMAT3X4, VAR_TYPE_DMAT4X2, VAR_TYPE_DMAT4X3, VAR_TYPE_DMAT4X4, 294 }; 295 296 const test_var_type* Interface::GL::var_types = var_types_gl; 297 const size_t Interface::GL::n_var_types = sizeof(var_types_gl) / sizeof(var_types_gl[0]); 298 299 /** List of all supported opaque types. */ 300 const glcts::test_var_type opaque_var_types[] = { 301 //Floating Point Sampler Types (opaque) 302 VAR_TYPE_SAMPLER2D, VAR_TYPE_SAMPLER3D, VAR_TYPE_SAMPLERCUBE, VAR_TYPE_SAMPLERCUBESHADOW, VAR_TYPE_SAMPLER2DSHADOW, 303 VAR_TYPE_SAMPLER2DARRAY, VAR_TYPE_SAMPLER2DARRAYSHADOW, 304 //Signed Integer Sampler Types (opaque) 305 VAR_TYPE_ISAMPLER2D, VAR_TYPE_ISAMPLER3D, VAR_TYPE_ISAMPLERCUBE, VAR_TYPE_ISAMPLER2DARRAY, 306 //Unsigned Integer Sampler Types (opaque) 307 VAR_TYPE_USAMPLER2D, VAR_TYPE_USAMPLER3D, VAR_TYPE_USAMPLERCUBE, VAR_TYPE_USAMPLER2DARRAY, 308 }; 309 310 /** Sets up the type map that will be used to look up the type names, initialisation 311 * values, etc., associated with each of the types used within the array tests 312 * 313 **/ 314 template <class API> 315 void initializeMap() 316 { 317 int temp_index = 0; 318 319 // Set up the map 320 supported_variable_types_map[VAR_TYPE_BOOL] = var_descriptors[temp_index++]; 321 supported_variable_types_map[VAR_TYPE_INT] = var_descriptors[temp_index++]; 322 supported_variable_types_map[VAR_TYPE_UINT] = var_descriptors[temp_index++]; 323 supported_variable_types_map[VAR_TYPE_FLOAT] = var_descriptors[temp_index++]; 324 supported_variable_types_map[VAR_TYPE_VEC2] = var_descriptors[temp_index++]; 325 supported_variable_types_map[VAR_TYPE_VEC3] = var_descriptors[temp_index++]; 326 supported_variable_types_map[VAR_TYPE_VEC4] = var_descriptors[temp_index++]; 327 supported_variable_types_map[VAR_TYPE_BVEC2] = var_descriptors[temp_index++]; 328 supported_variable_types_map[VAR_TYPE_BVEC3] = var_descriptors[temp_index++]; 329 supported_variable_types_map[VAR_TYPE_BVEC4] = var_descriptors[temp_index++]; 330 supported_variable_types_map[VAR_TYPE_IVEC2] = var_descriptors[temp_index++]; 331 supported_variable_types_map[VAR_TYPE_IVEC3] = var_descriptors[temp_index++]; 332 supported_variable_types_map[VAR_TYPE_IVEC4] = var_descriptors[temp_index++]; 333 supported_variable_types_map[VAR_TYPE_UVEC2] = var_descriptors[temp_index++]; 334 supported_variable_types_map[VAR_TYPE_UVEC3] = var_descriptors[temp_index++]; 335 supported_variable_types_map[VAR_TYPE_UVEC4] = var_descriptors[temp_index++]; 336 supported_variable_types_map[VAR_TYPE_MAT2] = var_descriptors[temp_index++]; 337 supported_variable_types_map[VAR_TYPE_MAT3] = var_descriptors[temp_index++]; 338 supported_variable_types_map[VAR_TYPE_MAT4] = var_descriptors[temp_index++]; 339 supported_variable_types_map[VAR_TYPE_MAT2X2] = var_descriptors[temp_index++]; 340 supported_variable_types_map[VAR_TYPE_MAT2X3] = var_descriptors[temp_index++]; 341 supported_variable_types_map[VAR_TYPE_MAT2X4] = var_descriptors[temp_index++]; 342 supported_variable_types_map[VAR_TYPE_MAT3X2] = var_descriptors[temp_index++]; 343 supported_variable_types_map[VAR_TYPE_MAT3X3] = var_descriptors[temp_index++]; 344 supported_variable_types_map[VAR_TYPE_MAT3X4] = var_descriptors[temp_index++]; 345 supported_variable_types_map[VAR_TYPE_MAT4X2] = var_descriptors[temp_index++]; 346 supported_variable_types_map[VAR_TYPE_MAT4X3] = var_descriptors[temp_index++]; 347 supported_variable_types_map[VAR_TYPE_MAT4X4] = var_descriptors[temp_index++]; 348 supported_variable_types_map[VAR_TYPE_IMAGEBUFFER] = var_descriptors[temp_index++]; 349 supported_variable_types_map[VAR_TYPE_IIMAGEBUFFER] = var_descriptors[temp_index++]; 350 supported_variable_types_map[VAR_TYPE_UIMAGEBUFFER] = var_descriptors[temp_index++]; 351 supported_variable_types_map[VAR_TYPE_SAMPLERBUFFER] = var_descriptors[temp_index++]; 352 supported_variable_types_map[VAR_TYPE_ISAMPLERBUFFER] = var_descriptors[temp_index++]; 353 supported_variable_types_map[VAR_TYPE_USAMPLERBUFFER] = var_descriptors[temp_index++]; 354 supported_variable_types_map[VAR_TYPE_SAMPLER2D] = var_descriptors[temp_index++]; 355 supported_variable_types_map[VAR_TYPE_SAMPLER3D] = var_descriptors[temp_index++]; 356 supported_variable_types_map[VAR_TYPE_SAMPLERCUBE] = var_descriptors[temp_index++]; 357 supported_variable_types_map[VAR_TYPE_SAMPLERCUBESHADOW] = var_descriptors[temp_index++]; 358 supported_variable_types_map[VAR_TYPE_SAMPLER2DSHADOW] = var_descriptors[temp_index++]; 359 supported_variable_types_map[VAR_TYPE_SAMPLER2DARRAY] = var_descriptors[temp_index++]; 360 supported_variable_types_map[VAR_TYPE_SAMPLER2DARRAYSHADOW] = var_descriptors[temp_index++]; 361 supported_variable_types_map[VAR_TYPE_ISAMPLER2D] = var_descriptors[temp_index++]; 362 supported_variable_types_map[VAR_TYPE_ISAMPLER3D] = var_descriptors[temp_index++]; 363 supported_variable_types_map[VAR_TYPE_ISAMPLERCUBE] = var_descriptors[temp_index++]; 364 supported_variable_types_map[VAR_TYPE_ISAMPLER2DARRAY] = var_descriptors[temp_index++]; 365 supported_variable_types_map[VAR_TYPE_USAMPLER2D] = var_descriptors[temp_index++]; 366 supported_variable_types_map[VAR_TYPE_USAMPLER3D] = var_descriptors[temp_index++]; 367 supported_variable_types_map[VAR_TYPE_USAMPLERCUBE] = var_descriptors[temp_index++]; 368 supported_variable_types_map[VAR_TYPE_USAMPLER2DARRAY] = var_descriptors[temp_index++]; 369 370 if (API::USE_DOUBLE) 371 { 372 temp_index = 0; 373 374 supported_variable_types_map[VAR_TYPE_DOUBLE] = var_double_descriptors[temp_index++]; 375 supported_variable_types_map[VAR_TYPE_DMAT2] = var_double_descriptors[temp_index++]; 376 supported_variable_types_map[VAR_TYPE_DMAT3] = var_double_descriptors[temp_index++]; 377 supported_variable_types_map[VAR_TYPE_DMAT4] = var_double_descriptors[temp_index++]; 378 supported_variable_types_map[VAR_TYPE_DMAT2X2] = var_double_descriptors[temp_index++]; 379 supported_variable_types_map[VAR_TYPE_DMAT2X3] = var_double_descriptors[temp_index++]; 380 supported_variable_types_map[VAR_TYPE_DMAT2X4] = var_double_descriptors[temp_index++]; 381 supported_variable_types_map[VAR_TYPE_DMAT3X2] = var_double_descriptors[temp_index++]; 382 supported_variable_types_map[VAR_TYPE_DMAT3X3] = var_double_descriptors[temp_index++]; 383 supported_variable_types_map[VAR_TYPE_DMAT3X4] = var_double_descriptors[temp_index++]; 384 supported_variable_types_map[VAR_TYPE_DMAT4X2] = var_double_descriptors[temp_index++]; 385 supported_variable_types_map[VAR_TYPE_DMAT4X3] = var_double_descriptors[temp_index++]; 386 supported_variable_types_map[VAR_TYPE_DMAT4X4] = var_double_descriptors[temp_index++]; 387 } 388 } 389 390 /** Macro appends default ending of main function to source string 391 * 392 * @param SOURCE Tested shader source 393 **/ 394 #define DEFAULT_MAIN_ENDING(TYPE, SOURCE) \ 395 { \ 396 /* Apply stage specific stuff */ \ 397 switch (TYPE) \ 398 { \ 399 case TestCaseBase<API>::VERTEX_SHADER_TYPE: \ 400 SOURCE += "\n gl_Position = vec4(0.0);\n"; \ 401 break; \ 402 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: \ 403 break; \ 404 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: \ 405 break; \ 406 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: \ 407 SOURCE += emit_quad; \ 408 break; \ 409 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: \ 410 SOURCE += set_tesseation; \ 411 break; \ 412 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: \ 413 break; \ 414 default: \ 415 TCU_FAIL("Unrecognized shader type."); \ 416 break; \ 417 } \ 418 \ 419 /* End main function */ \ 420 SOURCE += shader_end; \ 421 } 422 423 /** Macro executes positive test selected on USE_ALL_SHADER_STAGES 424 * 425 * @param TYPE Tested shader stage 426 * @param SOURCE Tested shader source 427 * @param DELETE Selects if program should be deleted afterwards 428 **/ 429 #define EXECUTE_POSITIVE_TEST(TYPE, SOURCE, DELETE, GPU5) \ 430 { \ 431 const std::string* cs = &empty_string; \ 432 const std::string* vs = &default_vertex_shader_source; \ 433 const std::string* tcs = &default_tc_shader_source; \ 434 const std::string* tes = &default_te_shader_source; \ 435 const std::string* gs = &default_geometry_shader_source; \ 436 const std::string* fs = &default_fragment_shader_source; \ 437 \ 438 switch (TYPE) \ 439 { \ 440 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: \ 441 cs = &SOURCE; \ 442 vs = &empty_string; \ 443 tcs = &empty_string; \ 444 tes = &empty_string; \ 445 gs = &empty_string; \ 446 fs = &empty_string; \ 447 break; \ 448 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: \ 449 fs = &SOURCE; \ 450 break; \ 451 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: \ 452 gs = &SOURCE; \ 453 break; \ 454 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: \ 455 tcs = &SOURCE; \ 456 break; \ 457 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: \ 458 tes = &SOURCE; \ 459 break; \ 460 case TestCaseBase<API>::VERTEX_SHADER_TYPE: \ 461 vs = &SOURCE; \ 462 break; \ 463 default: \ 464 TCU_FAIL("Invalid enum"); \ 465 break; \ 466 }; \ 467 \ 468 if (API::USE_ALL_SHADER_STAGES) \ 469 { \ 470 this->execute_positive_test(*vs, *tcs, *tes, *gs, *fs, *cs, DELETE, GPU5); \ 471 } \ 472 else \ 473 { \ 474 this->execute_positive_test(*vs, *fs, DELETE, GPU5); \ 475 } \ 476 } 477 478 /** Macro executes either positive or negative test 479 * 480 * @param S Selects negative test when 0, positive test otherwise 481 * @param TYPE Tested shader stage 482 * @param SOURCE Tested shader source 483 **/ 484 #define EXECUTE_SHADER_TEST(S, TYPE, SOURCE) \ 485 if (S) \ 486 { \ 487 EXECUTE_POSITIVE_TEST(TYPE, SOURCE, true, false); \ 488 } \ 489 else \ 490 { \ 491 this->execute_negative_test(TYPE, SOURCE); \ 492 } 493 494 /** Test case constructor. 495 * 496 * @tparam API Tested API descriptor 497 * 498 * @param context EGL context ID. 499 * @param name Name of a test case. 500 * @param description Test case description. 501 **/ 502 template <class API> 503 TestCaseBase<API>::TestCaseBase(Context& context, const char* name, const char* description) 504 : tcu::TestCase(context.getTestContext(), name, description) 505 , context_id(context) 506 , program_object_id(0) 507 , compute_shader_object_id(0) 508 , fragment_shader_object_id(0) 509 , geometry_shader_object_id(0) 510 , tess_ctrl_shader_object_id(0) 511 , tess_eval_shader_object_id(0) 512 , vertex_shader_object_id(0) 513 { 514 /* Left blank on purpose */ 515 } 516 517 /** Clears up the shaders and program that were created during the tests 518 * 519 * @tparam API Tested API descriptor 520 */ 521 template <class API> 522 void TestCaseBase<API>::delete_objects(void) 523 { 524 const glw::Functions& gl = context_id.getRenderContext().getFunctions(); 525 526 /* Release all ES objects that may have been created by iterate() */ 527 if (program_object_id != 0) 528 { 529 gl.deleteProgram(program_object_id); 530 program_object_id = 0; 531 } 532 533 /* Use default program object to be sure the objects were released. */ 534 gl.useProgram(0); 535 } 536 537 /** Releases all OpenGL ES objects that were created for test case purposes. 538 * 539 * @tparam API Tested API descriptor 540 */ 541 template <class API> 542 void TestCaseBase<API>::deinit(void) 543 { 544 this->delete_objects(); 545 } 546 547 /** Runs the actual test for each shader type. 548 * 549 * @tparam API Tested API descriptor 550 * 551 * @return QP_TEST_RESULT_FAIL - test has failed; 552 * QP_TEST_RESULT_PASS - test has succeeded; 553 **/ 554 template <class API> 555 tcu::TestNode::IterateResult TestCaseBase<API>::iterate(void) 556 { 557 test_shader_compilation(TestCaseBase<API>::VERTEX_SHADER_TYPE); 558 test_shader_compilation(TestCaseBase<API>::FRAGMENT_SHADER_TYPE); 559 560 if (API::USE_ALL_SHADER_STAGES) 561 { 562 test_shader_compilation(TestCaseBase<API>::COMPUTE_SHADER_TYPE); 563 test_shader_compilation(TestCaseBase<API>::GEOMETRY_SHADER_TYPE); 564 test_shader_compilation(TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE); 565 test_shader_compilation(TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE); 566 } 567 568 return STOP; 569 } 570 571 /** Generates a shader object of the specified type, 572 * attaches the specified shader source, 573 * compiles it, and returns the compilation result. 574 * 575 * @tparam API Tested API descriptor 576 * 577 * @param shader_source The source for the shader object. 578 * @param tested_shader_type The type of shader being compiled (vertex or fragment). 579 * 580 * @return Compilation result (GL_TRUE if the shader compilation succeeded, GL_FALSE otherwise). 581 **/ 582 template <class API> 583 glw::GLint TestCaseBase<API>::compile_shader_and_get_compilation_result(const std::string& tested_snippet, 584 TestShaderType tested_shader_type, 585 bool require_gpu_shader5) 586 { 587 static const char* preamble_cs = "\n" 588 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 589 "\n"; 590 591 static const char* preamble_gs = "\n" 592 "layout(points) in;\n" 593 "layout(triangle_strip, max_vertices = 4) out;\n" 594 "\n"; 595 596 static const char* preamble_tcs = "\n" 597 "layout(vertices = 1) out;\n" 598 "\n"; 599 600 static const char* preamble_tes = "\n" 601 "layout(isolines, point_mode) in;\n" 602 "\n"; 603 604 glw::GLint compile_status = GL_TRUE; 605 const glw::Functions& gl = context_id.getRenderContext().getFunctions(); 606 glw::GLint shader_object_id = 0; 607 608 std::string shader_source; 609 610 if (true == tested_snippet.empty()) 611 { 612 return compile_status; 613 } 614 615 if (require_gpu_shader5) 616 { 617 // Add the version number here, rather than in each individual test 618 shader_source = API::shader_version_gpu5; 619 } 620 else 621 { 622 // Add the version number here, rather than in each individual test 623 shader_source = API::shader_version; 624 } 625 626 /* Apply stage specific stuff */ 627 switch (tested_shader_type) 628 { 629 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 630 break; 631 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 632 break; 633 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 634 shader_source += preamble_cs; 635 break; 636 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 637 shader_source += preamble_gs; 638 break; 639 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 640 shader_source += preamble_tcs; 641 break; 642 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 643 shader_source += preamble_tes; 644 break; 645 default: 646 TCU_FAIL("Unrecognized shader type."); 647 break; 648 } 649 650 shader_source += tested_snippet; 651 652 /* Prepare shader object */ 653 switch (tested_shader_type) 654 { 655 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 656 { 657 shader_object_id = gl.createShader(GL_VERTEX_SHADER); 658 assert(0 == vertex_shader_object_id); 659 vertex_shader_object_id = shader_object_id; 660 661 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a vertex shader."); 662 663 break; 664 } /* case TestCaseBase<API>::VERTEX_SHADER_TYPE: */ 665 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 666 { 667 shader_object_id = gl.createShader(GL_FRAGMENT_SHADER); 668 assert(0 == fragment_shader_object_id); 669 fragment_shader_object_id = shader_object_id; 670 671 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a fragment shader."); 672 673 break; 674 } /* case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: */ 675 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 676 { 677 shader_object_id = gl.createShader(GL_COMPUTE_SHADER); 678 assert(0 == compute_shader_object_id); 679 compute_shader_object_id = shader_object_id; 680 681 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a compute shader."); 682 683 break; 684 } /* case TestCaseBase<API>::COMPUTE_SHADER_TYPE: */ 685 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 686 { 687 shader_object_id = gl.createShader(GL_GEOMETRY_SHADER); 688 assert(0 == geometry_shader_object_id); 689 geometry_shader_object_id = shader_object_id; 690 691 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a geometry shader."); 692 693 break; 694 } /* case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: */ 695 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 696 { 697 shader_object_id = gl.createShader(GL_TESS_CONTROL_SHADER); 698 assert(0 == tess_ctrl_shader_object_id); 699 tess_ctrl_shader_object_id = shader_object_id; 700 701 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a tesselation control shader."); 702 703 break; 704 } /* case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: */ 705 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 706 { 707 shader_object_id = gl.createShader(GL_TESS_EVALUATION_SHADER); 708 assert(0 == tess_eval_shader_object_id); 709 tess_eval_shader_object_id = shader_object_id; 710 711 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a tesselation evaluation shader."); 712 713 break; 714 } /* case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: */ 715 default: 716 { 717 TCU_FAIL("Unrecognized shader type."); 718 719 break; 720 } /* default: */ 721 } /* switch (tested_shader_type) */ 722 723 /* Assign source code to the objects */ 724 const char* code_ptr = shader_source.c_str(); 725 726 #if IS_DEBUG_DUMP_ALL_SHADERS 727 context_id.getTestContext().getLog() << tcu::TestLog::Message << "Compiling: " << tcu::TestLog::EndMessage; 728 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(code_ptr); 729 #endif /* IS_DEBUG_DUMP_ALL_SHADERS */ 730 731 gl.shaderSource(shader_object_id, 1 /* count */, &code_ptr, NULL); 732 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() failed"); 733 734 /* Compile the shader */ 735 gl.compileShader(shader_object_id); 736 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() failed"); 737 738 /* Get the compilation result. */ 739 gl.getShaderiv(shader_object_id, GL_COMPILE_STATUS, &compile_status); 740 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() failed"); 741 742 #if IS_DEBUG 743 if (GL_TRUE != compile_status) 744 { 745 glw::GLint length = 0; 746 std::string message; 747 748 /* Error log length */ 749 gl.getShaderiv(shader_object_id, GL_INFO_LOG_LENGTH, &length); 750 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); 751 752 /* Prepare storage */ 753 message.resize(length, 0); 754 755 /* Get error log */ 756 gl.getShaderInfoLog(shader_object_id, length, 0, &message[0]); 757 GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog"); 758 759 context_id.getTestContext().getLog() << tcu::TestLog::Message << "Error message: " << &message[0] 760 << tcu::TestLog::EndMessage; 761 762 #if IS_DEBUG_DUMP_ALL_SHADERS 763 #else /* IS_DEBUG_DUMP_ALL_SHADERS */ 764 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(code_ptr); 765 #endif /* IS_DEBUG_DUMP_ALL_SHADERS */ 766 } 767 #endif /* IS_DEBUG */ 768 769 return compile_status; 770 } 771 772 /** Runs the negative test. 773 * The shader sources are considered as invalid, 774 * and the compilation of a shader object with the specified 775 * shader source is expected to fail. 776 * 777 * @tparam API Tested API descriptor 778 * 779 * @param tested_shader_type The type of shader object (can be fragment or vertex). 780 * @param shader_source The source for the shader object to be used for this test. 781 * 782 * @return QP_TEST_RESULT_FAIL - test has failed; 783 * QP_TEST_RESULT_PASS - test has succeeded; 784 **/ 785 template <class API> 786 tcu::TestNode::IterateResult TestCaseBase<API>::execute_negative_test( 787 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& shader_source) 788 { 789 glw::GLint compile_status = GL_FALSE; 790 const char* error_message = 0; 791 const glw::Functions& gl = context_id.getRenderContext().getFunctions(); 792 bool test_result = true; 793 794 /* Try to generate and compile the shader object. */ 795 switch (tested_shader_type) 796 { 797 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 798 error_message = 799 "The fragment shader was expected to fail to compile, but the compilation process was successful."; 800 break; 801 802 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 803 error_message = 804 "The vertex shader was expected to fail to compile, but the compilation process was successful."; 805 806 break; 807 808 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 809 error_message = 810 "The compute shader was expected to fail to compile, but the compilation process was successful."; 811 break; 812 813 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 814 error_message = 815 "The geometry shader was expected to fail to compile, but the compilation process was successful."; 816 break; 817 818 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 819 error_message = "The tesselation control shader was expected to fail to compile, but the compilation process " 820 "was successful."; 821 break; 822 823 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 824 error_message = "The tesselation evaluation shader was expected to fail to compile, but the compilation " 825 "process was successful."; 826 break; 827 828 default: 829 TCU_FAIL("Unrecognized shader type."); 830 test_result = false; 831 832 break; 833 } /* switch (shader_type) */ 834 835 compile_status = compile_shader_and_get_compilation_result(shader_source, tested_shader_type); 836 837 if (compile_status == GL_TRUE) 838 { 839 TCU_FAIL(error_message); 840 841 test_result = false; 842 } 843 844 /* Deallocate any resources used. */ 845 this->delete_objects(); 846 if (0 != compute_shader_object_id) 847 { 848 gl.deleteShader(compute_shader_object_id); 849 compute_shader_object_id = 0; 850 } 851 if (0 != fragment_shader_object_id) 852 { 853 gl.deleteShader(fragment_shader_object_id); 854 fragment_shader_object_id = 0; 855 } 856 if (0 != geometry_shader_object_id) 857 { 858 gl.deleteShader(geometry_shader_object_id); 859 geometry_shader_object_id = 0; 860 } 861 if (0 != tess_ctrl_shader_object_id) 862 { 863 gl.deleteShader(tess_ctrl_shader_object_id); 864 tess_ctrl_shader_object_id = 0; 865 } 866 if (0 != tess_eval_shader_object_id) 867 { 868 gl.deleteShader(tess_eval_shader_object_id); 869 tess_eval_shader_object_id = 0; 870 } 871 if (0 != vertex_shader_object_id) 872 { 873 gl.deleteShader(vertex_shader_object_id); 874 vertex_shader_object_id = 0; 875 } 876 877 /* Return test pass if true. */ 878 if (true == test_result) 879 { 880 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 881 } 882 883 return CONTINUE; 884 } 885 886 /** Runs the positive test. 887 * The shader sources are considered as valid, 888 * and the compilation and program linking are expected to succeed. 889 * 890 * @tparam API Tested API descriptor 891 * 892 * @param vertex_shader_source The source for the vertex shader to be used for this test. 893 * @param fragment_shader_source The source for the fragment shader to be used for this test. 894 * @param delete_generated_objects If true, the compiled shader objects will be deleted before returning. 895 * 896 * @return QP_TEST_RESULT_FAIL - test has failed; 897 * QP_TEST_RESULT_PASS - test has succeeded; 898 **/ 899 template <class API> 900 tcu::TestNode::IterateResult TestCaseBase<API>::execute_positive_test(const std::string& vertex_shader_source, 901 const std::string& fragment_shader_source, 902 bool delete_generated_objects, 903 bool require_gpu_shader5) 904 { 905 glw::GLint compile_status = GL_TRUE; 906 const glw::Functions& gl = context_id.getRenderContext().getFunctions(); 907 glw::GLint link_status = GL_TRUE; 908 bool test_result = true; 909 910 /* Compile, and check the compilation result for the fragment shader object. */ 911 compile_status = compile_shader_and_get_compilation_result( 912 fragment_shader_source, TestCaseBase<API>::FRAGMENT_SHADER_TYPE, require_gpu_shader5); 913 914 if (compile_status == GL_FALSE) 915 { 916 TCU_FAIL("The fragment shader was expected to compile successfully, but failed to compile."); 917 918 test_result = false; 919 } 920 921 /* Compile, and check the compilation result for the vertex shader object. */ 922 compile_status = compile_shader_and_get_compilation_result( 923 vertex_shader_source, TestCaseBase<API>::VERTEX_SHADER_TYPE, require_gpu_shader5); 924 925 if (compile_status == GL_FALSE) 926 { 927 TCU_FAIL("The vertex shader was expected to compile successfully, but failed to compile."); 928 929 test_result = false; 930 } 931 932 if (true == test_result) 933 { 934 /* Create program object. */ 935 assert(0 == program_object_id); 936 program_object_id = gl.createProgram(); 937 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a program object."); 938 939 /* Configure the program object */ 940 gl.attachShader(program_object_id, fragment_shader_object_id); 941 gl.attachShader(program_object_id, vertex_shader_object_id); 942 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed."); 943 944 gl.deleteShader(fragment_shader_object_id); 945 gl.deleteShader(vertex_shader_object_id); 946 fragment_shader_object_id = 0; 947 vertex_shader_object_id = 0; 948 949 /* Link the program object */ 950 gl.linkProgram(program_object_id); 951 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed."); 952 953 /* Make sure the linking operation succeeded. */ 954 gl.getProgramiv(program_object_id, GL_LINK_STATUS, &link_status); 955 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed."); 956 957 if (link_status != GL_TRUE) 958 { 959 #if IS_DEBUG 960 glw::GLint length = 0; 961 std::string message; 962 963 /* Get error log length */ 964 gl.getProgramiv(program_object_id, GL_INFO_LOG_LENGTH, &length); 965 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 966 967 message.resize(length, 0); 968 969 /* Get error log */ 970 gl.getProgramInfoLog(program_object_id, length, 0, &message[0]); 971 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog"); 972 973 context_id.getTestContext().getLog() << tcu::TestLog::Message << "Error message: " << &message[0] 974 << tcu::TestLog::EndMessage; 975 976 #if IS_DEBUG_DUMP_ALL_SHADERS 977 #else /* IS_DEBUG_DUMP_ALL_SHADERS */ 978 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(vertex_shader_source); 979 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(fragment_shader_source); 980 #endif /* IS_DEBUG_DUMP_ALL_SHADERS */ 981 #endif /* IS_DEBUG */ 982 983 TCU_FAIL("Linking was expected to succeed, but the process was unsuccessful."); 984 985 test_result = false; 986 } 987 } 988 989 if (delete_generated_objects) 990 { 991 /* Deallocate any resources used. */ 992 this->delete_objects(); 993 } 994 995 /* Return test pass if true. */ 996 if (true == test_result) 997 { 998 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 999 } 1000 1001 return CONTINUE; 1002 } 1003 1004 /** Runs the positive test. 1005 * The shader sources are considered as valid, 1006 * and the compilation and program linking are expected to succeed. 1007 * 1008 * @tparam API Tested API descriptor 1009 * 1010 * @param vertex_shader_source The source for the vertex shader to be used for this test. 1011 * @param tess_ctrl_shader_source The source for the vertex shader to be used for this test. 1012 * @param tess_eval_shader_source The source for the vertex shader to be used for this test. 1013 * @param geometry_shader_source The source for the vertex shader to be used for this test. 1014 * @param fragment_shader_source The source for the vertex shader to be used for this test. 1015 * @param compute_shader_source The source for the fragment shader to be used for this test. 1016 * @param delete_generated_objects If true, the compiled shader objects will be deleted before returning. 1017 * 1018 * @return QP_TEST_RESULT_FAIL - test has failed; 1019 * QP_TEST_RESULT_PASS - test has succeeded; 1020 **/ 1021 template <class API> 1022 tcu::TestNode::IterateResult TestCaseBase<API>::execute_positive_test( 1023 const std::string& vertex_shader_source, const std::string& tess_ctrl_shader_source, 1024 const std::string& tess_eval_shader_source, const std::string& geometry_shader_source, 1025 const std::string& fragment_shader_source, const std::string& compute_shader_source, bool delete_generated_objects, 1026 bool require_gpu_shader5) 1027 { 1028 glw::GLint compile_status = GL_TRUE; 1029 const glw::Functions& gl = context_id.getRenderContext().getFunctions(); 1030 glw::GLint link_status = GL_TRUE; 1031 bool test_compute = !compute_shader_source.empty(); 1032 bool test_result = true; 1033 1034 if (false == test_compute) 1035 { 1036 /* Compile, and check the compilation result for the fragment shader object. */ 1037 compile_status = compile_shader_and_get_compilation_result( 1038 fragment_shader_source, TestCaseBase<API>::FRAGMENT_SHADER_TYPE, require_gpu_shader5); 1039 1040 if (compile_status == GL_FALSE) 1041 { 1042 TCU_FAIL("The fragment shader was expected to compile successfully, but failed to compile."); 1043 1044 test_result = false; 1045 } 1046 1047 /* Compile, and check the compilation result for the geometry shader object. */ 1048 compile_status = compile_shader_and_get_compilation_result( 1049 geometry_shader_source, TestCaseBase<API>::GEOMETRY_SHADER_TYPE, require_gpu_shader5); 1050 1051 if (compile_status == GL_FALSE) 1052 { 1053 TCU_FAIL("The geometry shader was expected to compile successfully, but failed to compile."); 1054 1055 test_result = false; 1056 } 1057 1058 /* Compile, and check the compilation result for the te shader object. */ 1059 compile_status = compile_shader_and_get_compilation_result( 1060 tess_eval_shader_source, TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE, require_gpu_shader5); 1061 1062 if (compile_status == GL_FALSE) 1063 { 1064 TCU_FAIL("The tesselation evaluation shader was expected to compile successfully, but failed to compile."); 1065 1066 test_result = false; 1067 } 1068 1069 /* Compile, and check the compilation result for the tc shader object. */ 1070 compile_status = compile_shader_and_get_compilation_result( 1071 tess_ctrl_shader_source, TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE, require_gpu_shader5); 1072 1073 if (compile_status == GL_FALSE) 1074 { 1075 TCU_FAIL("The tesselation control shader was expected to compile successfully, but failed to compile."); 1076 1077 test_result = false; 1078 } 1079 1080 /* Compile, and check the compilation result for the vertex shader object. */ 1081 compile_status = compile_shader_and_get_compilation_result( 1082 vertex_shader_source, TestCaseBase<API>::VERTEX_SHADER_TYPE, require_gpu_shader5); 1083 1084 if (compile_status == GL_FALSE) 1085 { 1086 TCU_FAIL("The vertex shader was expected to compile successfully, but failed to compile."); 1087 1088 test_result = false; 1089 } 1090 } 1091 else 1092 { 1093 /* Compile, and check the compilation result for the compute shader object. */ 1094 compile_status = compile_shader_and_get_compilation_result( 1095 compute_shader_source, TestCaseBase<API>::COMPUTE_SHADER_TYPE, require_gpu_shader5); 1096 1097 if (compile_status == GL_FALSE) 1098 { 1099 TCU_FAIL("The compute shader was expected to compile successfully, but failed to compile."); 1100 1101 test_result = false; 1102 } 1103 } 1104 1105 if (true == test_result) 1106 { 1107 /* Create program object. */ 1108 program_object_id = gl.createProgram(); 1109 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a program object."); 1110 1111 /* Configure the program object */ 1112 if (false == test_compute) 1113 { 1114 gl.attachShader(program_object_id, fragment_shader_object_id); 1115 1116 if (geometry_shader_object_id) 1117 { 1118 gl.attachShader(program_object_id, geometry_shader_object_id); 1119 } 1120 1121 if (tess_ctrl_shader_object_id) 1122 { 1123 gl.attachShader(program_object_id, tess_ctrl_shader_object_id); 1124 } 1125 1126 if (tess_eval_shader_object_id) 1127 { 1128 gl.attachShader(program_object_id, tess_eval_shader_object_id); 1129 } 1130 1131 gl.attachShader(program_object_id, vertex_shader_object_id); 1132 } 1133 else 1134 { 1135 gl.attachShader(program_object_id, compute_shader_object_id); 1136 } 1137 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() failed."); 1138 1139 if (false == test_compute) 1140 { 1141 gl.deleteShader(fragment_shader_object_id); 1142 1143 if (geometry_shader_object_id) 1144 { 1145 gl.deleteShader(geometry_shader_object_id); 1146 } 1147 1148 if (tess_ctrl_shader_object_id) 1149 { 1150 gl.deleteShader(tess_ctrl_shader_object_id); 1151 } 1152 1153 if (tess_eval_shader_object_id) 1154 { 1155 gl.deleteShader(tess_eval_shader_object_id); 1156 } 1157 1158 gl.deleteShader(vertex_shader_object_id); 1159 } 1160 else 1161 { 1162 gl.deleteShader(compute_shader_object_id); 1163 } 1164 1165 fragment_shader_object_id = 0; 1166 vertex_shader_object_id = 0; 1167 geometry_shader_object_id = 0; 1168 tess_ctrl_shader_object_id = 0; 1169 tess_eval_shader_object_id = 0; 1170 compute_shader_object_id = 0; 1171 1172 /* Link the program object */ 1173 gl.linkProgram(program_object_id); 1174 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() failed."); 1175 1176 /* Make sure the linking operation succeeded. */ 1177 gl.getProgramiv(program_object_id, GL_LINK_STATUS, &link_status); 1178 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() failed."); 1179 1180 if (link_status != GL_TRUE) 1181 { 1182 #if IS_DEBUG 1183 glw::GLint length = 0; 1184 std::string message; 1185 1186 /* Get error log length */ 1187 gl.getProgramiv(program_object_id, GL_INFO_LOG_LENGTH, &length); 1188 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); 1189 1190 message.resize(length, 0); 1191 1192 /* Get error log */ 1193 gl.getProgramInfoLog(program_object_id, length, 0, &message[0]); 1194 GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog"); 1195 1196 context_id.getTestContext().getLog() << tcu::TestLog::Message << "Error message: " << &message[0] 1197 << tcu::TestLog::EndMessage; 1198 1199 #if IS_DEBUG_DUMP_ALL_SHADERS 1200 if (false == test_compute) 1201 { 1202 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(vertex_shader_source); 1203 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(tess_ctrl_shader_source); 1204 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(tess_eval_shader_source); 1205 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(geometry_shader_source); 1206 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(fragment_shader_source); 1207 } 1208 else 1209 { 1210 context_id.getTestContext().getLog() << tcu::TestLog::KernelSource(compute_shader_source); 1211 } 1212 #endif /* IS_DEBUG_DUMP_ALL_SHADERS */ 1213 #endif /* IS_DEBUG */ 1214 1215 TCU_FAIL("Linking was expected to succeed, but the process was unsuccessful."); 1216 1217 test_result = false; 1218 } 1219 } 1220 1221 if (delete_generated_objects) 1222 { 1223 /* Deallocate any resources used. */ 1224 this->delete_objects(); 1225 } 1226 1227 /* Return test pass if true. */ 1228 if (true == test_result) 1229 { 1230 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1231 } 1232 1233 return CONTINUE; 1234 } 1235 1236 /** Adds the specified @param sub_script onto the base_string @param number_of_elements times. 1237 * E.g. extend_string("a", [2], 3) would give a[2][2][2]. 1238 * 1239 * @tparam API Tested API descriptor 1240 * 1241 * @param base_string The base string that is to be added to. 1242 * @param sub_string The string to be repeatedly added 1243 * @param number_of_elements The number of repetitions. 1244 * 1245 * @return The extended string. 1246 **/ 1247 template <class API> 1248 std::string TestCaseBase<API>::extend_string(std::string base_string, std::string sub_string, size_t number_of_elements) 1249 { 1250 std::string temp_string = base_string; 1251 1252 for (size_t sub_script_index = 0; sub_script_index < number_of_elements; sub_script_index++) 1253 { 1254 temp_string += sub_string; 1255 } 1256 1257 return temp_string; 1258 } 1259 1260 /* Generates the shader source code for the SizedDeclarationsPrimitive 1261 * array tests, and attempts to compile each test shader, for both 1262 * vertex and fragment shaders. 1263 * 1264 * @tparam API Tested API descriptor 1265 * 1266 * @param tested_shader_type The type of shader that is being tested 1267 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1268 * 1269 **/ 1270 template <class API> 1271 void SizedDeclarationsPrimitive<API>::test_shader_compilation( 1272 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1273 { 1274 for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++) 1275 { 1276 _supported_variable_types_map_const_iterator var_iterator = 1277 supported_variable_types_map.find(API::var_types[var_type_index]); 1278 1279 if (var_iterator != supported_variable_types_map.end()) 1280 { 1281 /* Loop round for each var_types ("int", "uint", "float", etc.) 1282 * We are testing a[][] to a [][][][][][][][], so start counter at 2. */ 1283 for (size_t max_dimension_limit = 2; max_dimension_limit <= API::MAX_ARRAY_DIMENSIONS; 1284 max_dimension_limit++) 1285 { 1286 // Record the base varTypeModifier + varType 1287 std::string base_var_type = var_iterator->second.type; 1288 std::string base_variable_string = base_var_type; 1289 1290 for (size_t base_sub_script_index = 0; base_sub_script_index <= max_dimension_limit; 1291 base_sub_script_index++) 1292 { 1293 std::string shader_source = ""; 1294 1295 // Add the shader body start, and the base varTypeModifier + varType + variable name. 1296 shader_source += shader_start + " " + base_variable_string + " a"; 1297 1298 for (size_t remaining_sub_script_index = base_sub_script_index; 1299 remaining_sub_script_index < max_dimension_limit; remaining_sub_script_index++) 1300 { 1301 /* Add as many array sub_scripts as we can, up to the current dimension limit. */ 1302 shader_source += "[2]"; 1303 } 1304 1305 /* End line */ 1306 shader_source += ";\n"; 1307 1308 /* End main */ 1309 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1310 1311 /* Execute test */ 1312 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1313 1314 /* From now on, we'll have an extra sub_script each time. */ 1315 base_variable_string += "[2]"; 1316 } /* for (int base_sub_script_index = 0; ...) */ 1317 } /* for (int max_dimension_limit = 2; ...) */ 1318 } /* if var_type iterator found */ 1319 else 1320 { 1321 TCU_FAIL("Type not found."); 1322 } 1323 } /* for (int var_type_index = 0; ...) */ 1324 } 1325 1326 /* Generates the shader source code for the SizedDeclarationsStructTypes1 1327 * array tests, and attempts to compile each test shader, for both 1328 * vertex and fragment shaders. 1329 * 1330 * @tparam API Tested API descriptor 1331 * 1332 * @param tested_shader_type The type of shader that is being tested 1333 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1334 */ 1335 template <class API> 1336 void SizedDeclarationsStructTypes1<API>::test_shader_compilation( 1337 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1338 { 1339 std::string example_struct("struct light {\n" 1340 " float intensity;\n" 1341 " int position;\n" 1342 "};\n\n"); 1343 std::string shader_source; 1344 1345 for (size_t max_dimension_index = 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1346 { 1347 shader_source = example_struct; 1348 shader_source += shader_start; 1349 shader_source += " light[2]"; 1350 1351 for (size_t temp_dimension_index = 0; temp_dimension_index < max_dimension_index; temp_dimension_index++) 1352 { 1353 shader_source += "[2]"; 1354 } 1355 1356 shader_source += " x;\n"; 1357 1358 /* End main */ 1359 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1360 1361 /* Execute test */ 1362 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1363 1364 } /* for (int max_dimension_index = 1; ...) */ 1365 } 1366 1367 /* Generates the shader source code for the SizedDeclarationsStructTypes2 1368 * array tests, and attempts to compile each test shader, for both 1369 * vertex and fragment shaders. 1370 * 1371 * @tparam API Tested API descriptor 1372 * 1373 * @param tested_shader_type The type of shader that is being tested 1374 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1375 */ 1376 template <class API> 1377 void SizedDeclarationsStructTypes2<API>::test_shader_compilation( 1378 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1379 { 1380 std::string structure_declaration = "struct MyStructure {\n" 1381 " float a[2], " 1382 "b[2][2], " 1383 "c[2][2][2], " 1384 "d[2][2][2][2], " 1385 "e[2][2][2][2][2], " 1386 "f[2][2][2][2][2][2], " 1387 "g[2][2][2][2][2][2][2], " 1388 "h[2][2][2][2][2][2][2][2];\n" 1389 "} myStructureObject;\n\n"; 1390 std::string shader_source = structure_declaration; 1391 1392 shader_source += shader_start; 1393 1394 /* End main */ 1395 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1396 1397 /* Execute test */ 1398 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1399 } 1400 1401 /* Generates the shader source code for the SizedDeclarationsStructTypes3 1402 * array tests, and attempts to compile each test shader, for both 1403 * vertex and fragment shaders. 1404 * 1405 * @tparam API Tested API descriptor 1406 * 1407 * @param tested_shader_type The type of shader that is being tested 1408 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1409 */ 1410 template <class API> 1411 void SizedDeclarationsStructTypes3<API>::test_shader_compilation( 1412 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1413 { 1414 std::string example_struct("struct light {\n" 1415 " float[2] intensity;\n" 1416 " int[2] position;\n" 1417 "};\n"); 1418 std::string shader_source; 1419 1420 for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1421 { 1422 shader_source = example_struct; 1423 shader_source += shader_start; 1424 shader_source += this->extend_string(" light my_light_object", "[2]", max_dimension_index); 1425 shader_source += ";\n"; 1426 1427 /* End main */ 1428 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1429 1430 /* Execute test */ 1431 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1432 } /* for (int max_dimension_index = 1; ...) */ 1433 } 1434 1435 /* Generates the shader source code for the SizedDeclarationsStructTypes4 1436 * array tests, and attempts to compile each test shader, for both 1437 * vertex and fragment shaders. 1438 * 1439 * @tparam API Tested API descriptor 1440 * 1441 * @param tested_shader_type The type of shader that is being tested 1442 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1443 */ 1444 template <class API> 1445 void SizedDeclarationsStructTypes4<API>::test_shader_compilation( 1446 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1447 { 1448 std::string example_struct("struct light {\n" 1449 " float[2] intensity;\n" 1450 " int[2] position;\n" 1451 "} lightVar[2]"); 1452 std::string shader_source; 1453 1454 for (size_t max_dimension_index = 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1455 { 1456 shader_source = example_struct; 1457 1458 for (size_t temp_dimension_index = 0; temp_dimension_index < max_dimension_index; temp_dimension_index++) 1459 { 1460 shader_source += "[2]"; 1461 } 1462 shader_source += ";\n\n"; 1463 shader_source += shader_start; 1464 1465 /* End main */ 1466 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1467 1468 /* Execute test */ 1469 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1470 } /* for (int max_dimension_index = 1; ...) */ 1471 } 1472 1473 /* Generates the shader source code for the SizedDeclarationsTypenameStyle1 1474 * array tests, and attempts to compile each test shader, for both 1475 * vertex and fragment shaders. 1476 * 1477 * @tparam API Tested API descriptor 1478 * 1479 * @param tested_shader_type The type of shader that is being tested 1480 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1481 */ 1482 template <class API> 1483 void SizedDeclarationsTypenameStyle1<API>::test_shader_compilation( 1484 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1485 { 1486 for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1487 { 1488 std::string shader_source = shader_start; 1489 1490 shader_source += this->extend_string(" float", "[2]", max_dimension_index); 1491 shader_source += this->extend_string(" x", "[2]", API::MAX_ARRAY_DIMENSIONS - max_dimension_index); 1492 shader_source += ";\n"; 1493 1494 /* End main */ 1495 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1496 1497 /* Execute test */ 1498 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1499 } /* for (int max_dimension_index = 1; ...) */ 1500 } 1501 1502 /* Generates the shader source code for the SizedDeclarationsTypenameStyle2 1503 * array tests, and attempts to compile each test shader, for both 1504 * vertex and fragment shaders. 1505 * 1506 * @tparam API Tested API descriptor 1507 * 1508 * @param tested_shader_type The type of shader that is being tested 1509 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1510 */ 1511 template <class API> 1512 void SizedDeclarationsTypenameStyle2<API>::test_shader_compilation( 1513 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1514 { 1515 std::string shader_source = shader_start; 1516 1517 shader_source += this->extend_string(" float", "[2]", 2); 1518 shader_source += this->extend_string(" a", "[2]", 0); 1519 shader_source += ", "; 1520 shader_source += this->extend_string("b", "[2]", 1); 1521 shader_source += ", "; 1522 shader_source += this->extend_string("c", "[2]", 2); 1523 shader_source += ", "; 1524 shader_source += this->extend_string("d", "[2]", 3); 1525 shader_source += ", "; 1526 shader_source += this->extend_string("e", "[2]", 4); 1527 shader_source += ", "; 1528 shader_source += this->extend_string("f", "[2]", 5); 1529 shader_source += ", "; 1530 shader_source += this->extend_string("g", "[2]", 6); 1531 shader_source += ";\n"; 1532 1533 /* End main */ 1534 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1535 1536 /* Execute test */ 1537 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1538 } 1539 1540 /* Generates the shader source code for the SizedDeclarationsTypenameStyle3 1541 * array tests, and attempts to compile each test shader, for both 1542 * vertex and fragment shaders. 1543 * 1544 * @tparam API Tested API descriptor 1545 * 1546 * @param tested_shader_type The type of shader that is being tested 1547 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1548 */ 1549 template <class API> 1550 void SizedDeclarationsTypenameStyle3<API>::test_shader_compilation( 1551 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1552 { 1553 std::string shader_source = "struct{\n" + this->extend_string(" float", "[2]", 2); 1554 1555 shader_source += this->extend_string(" a", "[2]", API::MAX_ARRAY_DIMENSIONS - API::MAX_ARRAY_DIMENSIONS); 1556 shader_source += ","; 1557 shader_source += this->extend_string(" b", "[2]", 1); 1558 shader_source += ","; 1559 shader_source += this->extend_string(" c", "[2]", 2); 1560 shader_source += ","; 1561 shader_source += this->extend_string(" d", "[2]", 3); 1562 shader_source += ","; 1563 shader_source += this->extend_string(" e", "[2]", 4); 1564 shader_source += ","; 1565 shader_source += this->extend_string(" f", "[2]", 5); 1566 shader_source += ","; 1567 shader_source += this->extend_string(" g", "[2]", 6); 1568 shader_source += ";\n} x;\n\n"; 1569 shader_source += shader_start; 1570 1571 /* End main */ 1572 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1573 1574 /* Execute test */ 1575 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1576 } 1577 1578 /* Generates the shader source code for the SizedDeclarationsTypenameStyle4 1579 * array tests, and attempts to compile each test shader, for both 1580 * vertex and fragment shaders. 1581 * 1582 * @tparam API Tested API descriptor 1583 * 1584 * @param tested_shader_type The type of shader that is being tested 1585 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1586 */ 1587 template <class API> 1588 void SizedDeclarationsTypenameStyle4<API>::test_shader_compilation( 1589 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1590 { 1591 std::string example_struct_begin("struct light {\n"); 1592 std::string example_struct_end("};\n\n"); 1593 1594 for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1595 { 1596 std::string shader_source = example_struct_begin; 1597 1598 shader_source += this->extend_string(" float", "[2]", max_dimension_index); 1599 shader_source += this->extend_string(" x", "[2]", API::MAX_ARRAY_DIMENSIONS - max_dimension_index); 1600 shader_source += ";\n"; 1601 shader_source += example_struct_end; 1602 shader_source += shader_start; 1603 1604 /* End main */ 1605 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1606 1607 /* Execute test */ 1608 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1609 } /* for (int max_dimension_index = 1; ...) */ 1610 } 1611 1612 /* Generates the shader source code for the SizedDeclarationsTypenameStyle5 1613 * array tests, and attempts to compile each test shader, for both 1614 * vertex and fragment shaders. 1615 * 1616 * @tparam API Tested API descriptor 1617 * 1618 * @param tested_shader_type The type of shader that is being tested 1619 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1620 */ 1621 template <class API> 1622 void SizedDeclarationsTypenameStyle5<API>::test_shader_compilation( 1623 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1624 { 1625 std::string example_struct_begin("struct light {\n"); 1626 std::string example_struct_end("};\n\n"); 1627 1628 std::string shader_source = example_struct_begin; 1629 1630 shader_source += this->extend_string(" float", "[2]", 2); 1631 shader_source += this->extend_string(" a", "[2]", API::MAX_ARRAY_DIMENSIONS - API::MAX_ARRAY_DIMENSIONS); 1632 shader_source += ", "; 1633 shader_source += this->extend_string("b", "[2]", 2); 1634 shader_source += ", "; 1635 shader_source += this->extend_string("c", "[2]", 3); 1636 shader_source += ", "; 1637 shader_source += this->extend_string("d", "[2]", 4); 1638 shader_source += ", "; 1639 shader_source += this->extend_string("e", "[2]", 5); 1640 shader_source += ", "; 1641 shader_source += this->extend_string("f", "[2]", 6); 1642 shader_source += ";\n"; 1643 shader_source += example_struct_end; 1644 shader_source += shader_start; 1645 1646 /* End main */ 1647 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1648 1649 /* Execute test */ 1650 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1651 } 1652 1653 /* Generates the shader source code for the SizedDeclarationsFunctionParams 1654 * array tests, and attempts to compile each test shader, for both 1655 * vertex and fragment shaders. 1656 * 1657 * @tparam API Tested API descriptor 1658 * 1659 * @param tested_shader_type The type of shader that is being tested 1660 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1661 */ 1662 template <class API> 1663 void SizedDeclarationsFunctionParams<API>::test_shader_compilation( 1664 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1665 { 1666 size_t dimension_index = 0; 1667 std::string example_struct1("\nvoid my_function("); 1668 std::string example_struct2(")\n" 1669 "{\n" 1670 "}\n\n"); 1671 std::string base_variable_string; 1672 std::string variable_basenames[API::MAX_ARRAY_DIMENSIONS] = { "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8" }; 1673 std::string full_variable_names[API::MAX_ARRAY_DIMENSIONS]; 1674 1675 for (size_t max_dimension_index = 0; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1676 { 1677 full_variable_names[max_dimension_index] = 1678 this->extend_string(variable_basenames[max_dimension_index], "[2]", max_dimension_index + 1); 1679 } 1680 1681 for (size_t max_dimension_index = 0; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1682 { 1683 base_variable_string += "float "; 1684 base_variable_string += full_variable_names[max_dimension_index]; 1685 base_variable_string += ";\n"; 1686 } 1687 1688 base_variable_string += example_struct1; 1689 base_variable_string += this->extend_string("float a", "[2]", 1); 1690 base_variable_string += ", "; 1691 base_variable_string += this->extend_string("float b", "[2]", 2); 1692 base_variable_string += ", "; 1693 base_variable_string += this->extend_string("float c", "[2]", 3); 1694 base_variable_string += ", "; 1695 base_variable_string += this->extend_string("float d", "[2]", 4); 1696 base_variable_string += ", "; 1697 base_variable_string += this->extend_string("float e", "[2]", 5); 1698 base_variable_string += ", "; 1699 base_variable_string += this->extend_string("float f", "[2]", 6); 1700 base_variable_string += ", "; 1701 base_variable_string += this->extend_string("float g", "[2]", 7); 1702 base_variable_string += ", "; 1703 base_variable_string += this->extend_string("float h", "[2]", 8); 1704 base_variable_string += example_struct2; 1705 1706 std::string shader_source = base_variable_string; 1707 1708 shader_source += shader_start; 1709 shader_source += " my_function("; 1710 1711 for (dimension_index = 0; dimension_index < API::MAX_ARRAY_DIMENSIONS - 1; dimension_index++) 1712 { 1713 shader_source += variable_basenames[dimension_index]; 1714 shader_source += ", "; 1715 } 1716 1717 shader_source += variable_basenames[dimension_index]; 1718 shader_source += ");\n"; 1719 1720 /* End main */ 1721 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1722 1723 /* Execute test */ 1724 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 1725 1726 /* Only the previous case should succeed, so start from index 1 rather than 0. 1727 * The other cases should fail, so only compile them, rather than trying to also link them. 1728 * We'll swap items 2/3, then 2/4, then 2/5, then 2/6, ... 1729 * Then we'll swap items 3/4, then 3/5, ... 1730 * Repeat, starting for 4/5-8, 5/6-8, 6/7-8... 1731 * Finally, we'll swap items 7/8 1732 */ 1733 for (size_t swap_item = 1; swap_item < API::MAX_ARRAY_DIMENSIONS; swap_item++) 1734 { 1735 for (size_t max_dimension_index = swap_item + 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; 1736 max_dimension_index++) 1737 { 1738 std::string temp = variable_basenames[swap_item]; 1739 1740 shader_source = base_variable_string; 1741 variable_basenames[swap_item] = variable_basenames[max_dimension_index]; 1742 variable_basenames[max_dimension_index] = temp; 1743 1744 shader_source += shader_start; 1745 shader_source += " my_function("; 1746 1747 for (dimension_index = 0; dimension_index < API::MAX_ARRAY_DIMENSIONS - 1; dimension_index++) 1748 { 1749 shader_source += variable_basenames[dimension_index]; 1750 shader_source += ", "; 1751 } 1752 1753 shader_source += variable_basenames[dimension_index]; 1754 shader_source += ");\n"; 1755 1756 temp = variable_basenames[swap_item]; 1757 variable_basenames[swap_item] = variable_basenames[max_dimension_index]; 1758 variable_basenames[max_dimension_index] = temp; 1759 1760 /* End main */ 1761 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1762 1763 /* Execute test */ 1764 this->execute_negative_test(tested_shader_type, shader_source); 1765 } /* for (int max_dimension_index = swap_item + 1; ...) */ 1766 } /* for (int swap_item = 1; ...) */ 1767 } 1768 1769 /* Generates the shader source code for the sized_declarations_invalid_sizes1 1770 * array tests, and attempts to compile each test shader, for both 1771 * vertex and fragment shaders. 1772 * 1773 * @tparam API Tested API descriptor 1774 * 1775 * @param tested_shader_type The type of shader that is being tested 1776 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1777 */ 1778 template <class API> 1779 void sized_declarations_invalid_sizes1<API>::test_shader_compilation( 1780 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1781 { 1782 std::string invalid_declarations[] = { 1783 "float x[2][2][2][0];\n", "float x[2][2][0][2];\n", "float x[2][0][2][2];\n", "float x[0][2][2][2];\n", 1784 "float x[2][2][0][0];\n", "float x[2][0][2][0];\n", "float x[0][2][2][0];\n", "float x[2][0][0][2];\n", 1785 "float x[0][2][0][2];\n", "float x[0][0][2][2];\n", "float x[2][0][0][0];\n", "float x[0][2][0][0];\n", 1786 "float x[0][0][2][0];\n", "float x[0][0][0][2];\n", "float x[0][0][0][0];\n" 1787 }; 1788 1789 for (size_t invalid_declarations_index = 0; 1790 invalid_declarations_index < sizeof(invalid_declarations) / sizeof(invalid_declarations); 1791 invalid_declarations_index++) 1792 { 1793 std::string shader_source; 1794 1795 shader_source = shader_start; 1796 shader_source += invalid_declarations[invalid_declarations_index]; 1797 1798 /* End main */ 1799 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1800 1801 /* Execute test */ 1802 this->execute_negative_test(tested_shader_type, shader_source); 1803 } /* for (int invalid_declarations_index = 0; ...) */ 1804 } 1805 1806 /* Generates the shader source code for the sized_declarations_invalid_sizes2 1807 * array tests, and attempts to compile each test shader, for both 1808 * vertex and fragment shaders. 1809 * 1810 * @tparam API Tested API descriptor 1811 * 1812 * @param tested_shader_type The type of shader that is being tested 1813 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1814 */ 1815 template <class API> 1816 void sized_declarations_invalid_sizes2<API>::test_shader_compilation( 1817 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1818 { 1819 std::string invalid_declarations[] = { 1820 " float x[2][2][2][-1];\n", " float x[2][2][-1][2];\n", " float x[2][-1][2][2];\n", 1821 " float x[-1][2][2][2];\n", " float x[2][2][-1][-1];\n", " float x[2][-1][2][-1];\n", 1822 " float x[-1][2][2][-1];\n", " float x[2][-1][-1][2];\n", " float x[-1][2][-1][2];\n", 1823 " float x[-1][-1][2][2];\n", " float x[2][-1][-1][-1];\n", " float x[-1][2][-1][-1];\n", 1824 " float x[-1][-1][2][-1];\n", " float x[-1][-1][-1][2];\n", " float x[-1][-1][-1][-1];\n" 1825 }; 1826 1827 for (size_t invalid_declarations_index = 0; 1828 invalid_declarations_index < sizeof(invalid_declarations) / sizeof(invalid_declarations); 1829 invalid_declarations_index++) 1830 { 1831 std::string shader_source; 1832 1833 shader_source = shader_start; 1834 shader_source += invalid_declarations[invalid_declarations_index]; 1835 1836 /* End main */ 1837 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1838 1839 /* Execute test */ 1840 this->execute_negative_test(tested_shader_type, shader_source); 1841 } /* for (int invalid_declarations_index = 0; ...) */ 1842 } 1843 1844 /* Generates the shader source code for the sized_declarations_invalid_sizes3 1845 * array tests, and attempts to compile each test shader, for both 1846 * vertex and fragment shaders. 1847 * 1848 * @tparam API Tested API descriptor 1849 * 1850 * @param tested_shader_type The type of shader that is being tested 1851 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1852 */ 1853 template <class API> 1854 void sized_declarations_invalid_sizes3<API>::test_shader_compilation( 1855 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1856 { 1857 std::string invalid_declarations[] = { 1858 " float x[2][2][2][a];\n", " float x[2][2][a][2];\n", " float x[2][a][2][2];\n", 1859 " float x[a][2][2][2];\n", " float x[2][2][a][a];\n", " float x[2][a][2][a];\n", 1860 " float x[a][2][2][a];\n", " float x[2][a][a][2];\n", " float x[a][2][a][2];\n", 1861 " float x[a][a][2][2];\n", " float x[2][a][a][a];\n", " float x[a][2][a][a];\n", 1862 " float x[a][a][2][a];\n", " float x[a][a][a][2];\n", " float x[a][a][a][a];\n" 1863 }; 1864 std::string non_constant_variable_declaration = " uint a = 2u;\n"; 1865 1866 for (size_t invalid_declarations_index = 0; 1867 invalid_declarations_index < sizeof(invalid_declarations) / sizeof(invalid_declarations); 1868 invalid_declarations_index++) 1869 { 1870 std::string shader_source; 1871 1872 shader_source = shader_start; 1873 shader_source += non_constant_variable_declaration; 1874 shader_source += invalid_declarations[invalid_declarations_index]; 1875 1876 /* End main */ 1877 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1878 1879 /* Execute test */ 1880 this->execute_negative_test(tested_shader_type, shader_source); 1881 } /* for (int invalid_declarations_index = 0; ...) */ 1882 } 1883 1884 /* Generates the shader source code for the sized_declarations_invalid_sizes4 1885 * array tests, and attempts to compile each test shader, for both 1886 * vertex and fragment shaders. 1887 * 1888 * @tparam API Tested API descriptor 1889 * 1890 * @param tested_shader_type The type of shader that is being tested 1891 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1892 */ 1893 template <class API> 1894 void sized_declarations_invalid_sizes4<API>::test_shader_compilation( 1895 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1896 { 1897 std::string input[] = { " float x[2,2][2][2];\n", " float x[2][2,2][2];\n", " float x[2][2][2,2];\n", 1898 " float x[2,2,2][2];\n", " float x[2][2,2,2];\n", " float x[2,2,2,2];\n" }; 1899 1900 for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++) 1901 { 1902 std::string shader_source; 1903 1904 shader_source += shader_start; 1905 shader_source += input[string_index]; 1906 1907 /* End main */ 1908 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1909 1910 /* Execute test */ 1911 this->execute_negative_test(tested_shader_type, shader_source); 1912 } /* for (int string_index = 0; ...) */ 1913 } 1914 1915 /* Constructs a suitable constructor for the specified number of dimensions. 1916 * 1917 * @tparam API Tested API descriptor 1918 * 1919 * @param var_type The type of the variable 1920 * @param dimension_index The current recursion level (counts down) 1921 * @param init_string The initialisation string 1922 */ 1923 template <class API> 1924 std::string ConstructorsAndUnsizedDeclConstructors1<API>::recursively_initialise(std::string var_type, 1925 size_t dimension_index, 1926 std::string init_string) 1927 { 1928 std::string temp_string; 1929 1930 if (dimension_index == 0) 1931 { 1932 temp_string = init_string; 1933 } 1934 else 1935 { 1936 std::string prefix = "\n"; 1937 1938 for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++) 1939 { 1940 prefix += " "; 1941 } 1942 1943 prefix += this->extend_string(var_type, "[]", dimension_index); 1944 prefix += "("; 1945 for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++) 1946 { 1947 temp_string += prefix; 1948 temp_string += recursively_initialise(var_type, dimension_index - 1, init_string); 1949 prefix = ", "; 1950 if (sub_script_index == 1) 1951 { 1952 break; 1953 } 1954 } 1955 temp_string += ")"; 1956 } 1957 1958 return temp_string; 1959 } 1960 1961 /* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructors1 1962 * array tests, and attempts to compile each test shader, for both 1963 * vertex and fragment shaders. 1964 * 1965 * @tparam API Tested API descriptor 1966 * 1967 * @param tested_shader_type The type of shader that is being tested 1968 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 1969 */ 1970 template <class API> 1971 void ConstructorsAndUnsizedDeclConstructors1<API>::test_shader_compilation( 1972 typename TestCaseBase<API>::TestShaderType tested_shader_type) 1973 { 1974 //vec4 color = vec4(0.0, 1.0, 0.0, 1.0); 1975 int num_var_types = API::n_var_types; 1976 1977 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 1978 { 1979 _supported_variable_types_map_const_iterator var_iterator = 1980 supported_variable_types_map.find(API::var_types[var_type_index]); 1981 1982 if (var_iterator != supported_variable_types_map.end()) 1983 { 1984 for (size_t max_dimension_index = 2; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 1985 { 1986 std::string base_variable_string = 1987 this->extend_string(" " + var_iterator->second.type + " a", "[]", max_dimension_index); 1988 1989 base_variable_string += " = "; 1990 base_variable_string += recursively_initialise(var_iterator->second.type, max_dimension_index, 1991 var_iterator->second.initializer_with_ones); 1992 base_variable_string += ";\n\n"; 1993 1994 std::string shader_source = shader_start + base_variable_string; 1995 1996 /* End main */ 1997 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 1998 1999 /* Execute test */ 2000 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2001 } /* for (int max_dimension_index = 1; ...) */ 2002 } /* if var_type iterator found */ 2003 else 2004 { 2005 TCU_FAIL("Type not found."); 2006 } 2007 } /* for (int var_type_index = 0; ...) */ 2008 2009 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 2010 { 2011 _supported_variable_types_map_const_iterator var_iterator = 2012 supported_variable_types_map.find(API::var_types[var_type_index]); 2013 2014 if (var_iterator != supported_variable_types_map.end()) 2015 { 2016 std::string base_structure = "struct my_structure\n"; 2017 2018 base_structure += "{\n"; 2019 base_structure += " " + var_iterator->second.type + " b;\n"; 2020 base_structure += " " + var_iterator->second.type + " c;\n"; 2021 base_structure += "};\n\n"; 2022 2023 for (size_t max_dimension_index = 1; max_dimension_index < API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 2024 { 2025 std::string outer_separator = "("; 2026 std::string base_variable_string; 2027 2028 base_variable_string += 2029 this->extend_string(" " + var_iterator->second.type + " a", "[2]", max_dimension_index); 2030 base_variable_string += " = "; 2031 base_variable_string += recursively_initialise(var_iterator->second.type, max_dimension_index, 2032 var_iterator->second.initializer_with_ones); 2033 base_variable_string += ";\n\n"; 2034 2035 std::string shader_source = base_structure + shader_start + base_variable_string; 2036 2037 /* End main */ 2038 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2039 2040 /* Execute test */ 2041 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2042 } /* for (int max_dimension_index = 1; ...) */ 2043 } /* if var_type iterator found */ 2044 else 2045 { 2046 TCU_FAIL("Type not found."); 2047 } 2048 } /* for (int var_type_index = 0; ...) */ 2049 } 2050 2051 /* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructors2 2052 * array tests, and attempts to compile each test shader, for both 2053 * vertex and fragment shaders. 2054 * 2055 * @tparam API Tested API descriptor 2056 * 2057 * @param tested_shader_type The type of shader that is being tested 2058 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2059 */ 2060 template <class API> 2061 void ConstructorsAndUnsizedDeclConstructors2<API>::test_shader_compilation( 2062 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2063 { 2064 std::string base_variable_string = " float[2][2] x = float[2][2](float[4](1.0, 2.0, 3.0, 4.0));\n"; 2065 std::string shader_source = shader_start + base_variable_string; 2066 2067 /* End main */ 2068 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2069 2070 /* Execute test */ 2071 this->execute_negative_test(tested_shader_type, shader_source); 2072 2073 base_variable_string = "float[2][2] x = float[2][2](float[1][4](float[4](1.0, 2.0, 3.0, 4.0)));\n\n"; 2074 shader_source = base_variable_string + shader_start; 2075 2076 /* End main */ 2077 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2078 2079 /* Execute test */ 2080 this->execute_negative_test(tested_shader_type, shader_source); 2081 } 2082 2083 /* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedConstructors 2084 * array tests, and attempts to compile each test shader, for both 2085 * vertex and fragment shaders. 2086 * 2087 * @tparam API Tested API descriptor 2088 * 2089 * @param tested_shader_type The type of shader that is being tested 2090 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2091 */ 2092 template <class API> 2093 void ConstructorsAndUnsizedDeclUnsizedConstructors<API>::test_shader_compilation( 2094 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2095 { 2096 std::string shader_variable_declarations = "= float[2][1][2][1](\n" 2097 " float[1][2][1](\n" 2098 " float[2][1]( \n" 2099 " float[1](12.3), float[1](54.2) \n" 2100 " )\n" 2101 " ),\n" 2102 " float[1][2][1](\n" 2103 " float[2][1]( \n" 2104 " float[1]( 3.2), float[1]( 7.4) \n" 2105 " )\n" 2106 " )\n" 2107 " );\n\n"; 2108 2109 std::string input[] = { "float a[2][1][2][]", "float a[2][1][][1]", "float a[2][1][][]", "float a[2][][2][1]", 2110 "float a[2][][2][]", "float a[2][][][1]", "float a[2][][][]", "float a[][1][2][1]", 2111 "float a[][1][2][]", "float a[][1][][1]", "float a[][1][][]", "float a[][][2][1]", 2112 "float a[][][2][]", "float a[][][][1]", "float a[][][][]" }; 2113 2114 for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++) 2115 { 2116 std::string shader_source = shader_start + " " + input[string_index] + shader_variable_declarations; 2117 2118 /* End main */ 2119 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2120 2121 /* Execute test */ 2122 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2123 } /* for (int string_index = 0; ...) */ 2124 } 2125 2126 /* Generates the shader source code for the ConstructorsAndUnsizedDeclConst 2127 * array tests, and attempts to compile each test shader, for both 2128 * vertex and fragment shaders. 2129 * 2130 * @tparam API Tested API descriptor 2131 * 2132 * @param tested_shader_type The type of shader that is being tested 2133 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2134 */ 2135 template <class API> 2136 void ConstructorsAndUnsizedDeclConst<API>::test_shader_compilation( 2137 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2138 { 2139 std::string shader_source = "const float[2][2] x = float[2][2](float[2](1.0, 2.0), float[2](3.0, 4.0));\n\n"; 2140 shader_source += shader_start; 2141 2142 /* End main */ 2143 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2144 2145 /* Execute test */ 2146 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2147 } 2148 2149 /* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors1 2150 * array tests, and attempts to compile each test shader, for both 2151 * vertex and fragment shaders. 2152 * 2153 * @tparam API Tested API descriptor 2154 * 2155 * @param tested_shader_type The type of shader that is being tested 2156 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2157 */ 2158 template <class API> 2159 void ConstructorsAndUnsizedDeclInvalidConstructors1<API>::test_shader_compilation( 2160 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2161 { 2162 int num_var_types = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]); 2163 2164 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 2165 { 2166 _supported_variable_types_map_const_iterator var_iterator = 2167 supported_variable_types_map.find(opaque_var_types[var_type_index]); 2168 2169 if (var_iterator != supported_variable_types_map.end()) 2170 { 2171 std::string base_variable_string = 2172 "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler1;\n" + 2173 "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler2;\n" + 2174 "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler3;\n" + 2175 "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " my_sampler4;\n\n"; 2176 2177 std::string shader_source = base_variable_string + shader_start; 2178 shader_source += " const " + var_iterator->second.type + "[2][2] x = " + var_iterator->second.type + 2179 "[2][2](" + var_iterator->second.type + "[2](my_sampler1, my_sampler2), " + 2180 var_iterator->second.type + "[2](my_sampler3, my_sampler4));\n\n"; 2181 2182 /* End main */ 2183 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2184 2185 /* Execute test */ 2186 this->execute_negative_test(tested_shader_type, shader_source); 2187 } /* if var_type iterator found */ 2188 else 2189 { 2190 TCU_FAIL("Type not found."); 2191 } 2192 } /* for (int var_type_index = 0; ...) */ 2193 } 2194 2195 /* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors2 2196 * array tests, and attempts to compile each test shader, for both 2197 * vertex and fragment shaders. 2198 * 2199 * @tparam API Tested API descriptor 2200 * 2201 * @param tested_shader_type The type of shader that is being tested 2202 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2203 */ 2204 template <class API> 2205 void ConstructorsAndUnsizedDeclInvalidConstructors2<API>::test_shader_compilation( 2206 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2207 { 2208 std::string invalid_initializers[] = { " int x[2][2][0]; \n", " int x[2][0][2]; \n", " int x[0][2][2]; \n", 2209 " int x[2][0][0]; \n", " int x[0][2][0]; \n", " int x[0][0][2]; \n", 2210 " int x[0][0][0]; \n" }; 2211 2212 for (size_t invalid_initializers_index = 0; 2213 invalid_initializers_index < sizeof(invalid_initializers) / sizeof(invalid_initializers[0]); 2214 invalid_initializers_index++) 2215 { 2216 std::string shader_source; 2217 2218 shader_source = shader_start; 2219 shader_source += invalid_initializers[invalid_initializers_index]; 2220 2221 /* End main */ 2222 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2223 2224 /* Execute test */ 2225 this->execute_negative_test(tested_shader_type, shader_source); 2226 } /* for (int invalid_initializers_index = 0; ...) */ 2227 } 2228 2229 /* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors3 2230 * array tests, and attempts to compile each test shader, for both 2231 * vertex and fragment shaders. 2232 * 2233 * @tparam API Tested API descriptor 2234 * 2235 * @param tested_shader_type The type of shader that is being tested 2236 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2237 */ 2238 template <class API> 2239 void ConstructorsAndUnsizedDeclInvalidConstructors3<API>::test_shader_compilation( 2240 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2241 { 2242 std::string invalid_initializers[] = { " int x[2][2][-1]; \n", " int x[2][-1][2]; \n", 2243 " int x[-1][2][2]; \n", " int x[2][-1][-1]; \n", 2244 " int x[-1][2][-1]; \n", " int x[-1][-1][2]; \n", 2245 " int x[-1][-1][-1]; \n" }; 2246 2247 for (size_t invalid_initializers_index = 0; 2248 invalid_initializers_index < sizeof(invalid_initializers) / sizeof(invalid_initializers[0]); 2249 invalid_initializers_index++) 2250 { 2251 std::string shader_source; 2252 2253 shader_source = shader_start; 2254 shader_source += invalid_initializers[invalid_initializers_index]; 2255 2256 /* End main */ 2257 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2258 2259 /* Execute test */ 2260 this->execute_negative_test(tested_shader_type, shader_source); 2261 } /* for (int invalid_initializers_index = 0; ...) */ 2262 } 2263 2264 /* Generates the shader source code for the ConstructorsAndUnsizedDeclInvalidConstructors4 2265 * array tests, and attempts to compile each test shader, for both 2266 * vertex and fragment shaders. 2267 * 2268 * @tparam API Tested API descriptor 2269 * 2270 * @param tested_shader_type The type of shader that is being tested 2271 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2272 */ 2273 template <class API> 2274 void ConstructorsAndUnsizedDeclInvalidConstructors4<API>::test_shader_compilation( 2275 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2276 { 2277 std::string invalid_initializers[] = { " int x[2][2][a]; \n", " int x[2][a][2]; \n", " int x[a][2][2]; \n", 2278 " int x[2][a][a]; \n", " int x[a][2][a]; \n", " int x[a][a][2]; \n", 2279 " int x[a][a][a]; \n" }; 2280 std::string non_constant_variable_init = " uint a = 2u;\n"; 2281 2282 for (size_t invalid_initializers_index = 0; 2283 invalid_initializers_index < sizeof(invalid_initializers) / sizeof(invalid_initializers[0]); 2284 invalid_initializers_index++) 2285 { 2286 std::string shader_source; 2287 2288 shader_source = shader_start; 2289 shader_source += non_constant_variable_init; 2290 shader_source += invalid_initializers[invalid_initializers_index]; 2291 2292 /* End main */ 2293 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2294 2295 /* Execute test */ 2296 this->execute_negative_test(tested_shader_type, shader_source); 2297 } /* for (int invalid_initializers_index = 0; ...) */ 2298 } 2299 2300 /* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructorSizing1 2301 * array tests, and attempts to compile each test shader, for both 2302 * vertex and fragment shaders. 2303 * 2304 * @tparam API Tested API descriptor 2305 * 2306 * @param tested_shader_type The type of shader that is being tested 2307 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2308 */ 2309 template <class API> 2310 void ConstructorsAndUnsizedDeclConstructorSizing1<API>::test_shader_compilation( 2311 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2312 { 2313 std::string valid_size_initializers[] = { "[1][1][1][]", "[1][1][][1]", "[1][][1][1]", "[][1][1][1]", "[1][1][][]", 2314 "[1][][1][]", "[][1][1][]", "[1][][][1]", "[][1][][1]", "[][][1][1]", 2315 "[1][][][]", "[][1][][]", "[][][1][]", "[][][][1]", "[][][][]" }; 2316 2317 for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++) 2318 { 2319 _supported_variable_types_map_const_iterator var_iterator = 2320 supported_variable_types_map.find(API::var_types[var_type_index]); 2321 2322 if (var_iterator != supported_variable_types_map.end()) 2323 { 2324 for (size_t valid_size_initializers_index = 0; 2325 valid_size_initializers_index < sizeof(valid_size_initializers) / sizeof(valid_size_initializers[0]); 2326 valid_size_initializers_index++) 2327 { 2328 std::string shader_source; 2329 std::string variable_constructor = 2330 " " + var_iterator->second.type + " x" + valid_size_initializers[valid_size_initializers_index] + 2331 " = " + var_iterator->second.type + "[1][1][1][1](" + var_iterator->second.type + "[1][1][1](" + 2332 var_iterator->second.type + "[1][1](" + var_iterator->second.type + "[1](" + 2333 var_iterator->second.initializer_with_zeroes + "))));\n"; 2334 2335 shader_source = shader_start; 2336 shader_source += variable_constructor; 2337 2338 /* End main */ 2339 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2340 2341 /* Execute test */ 2342 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2343 } /* for (int valid_size_initializers_index = 0; ...) */ 2344 } /* if var_type iterator found */ 2345 else 2346 { 2347 TCU_FAIL("Type not found."); 2348 } 2349 } /* for (int var_type_index = 0; ...) */ 2350 } 2351 2352 /* Generates the shader source code for the ConstructorsAndUnsizedDeclConstructorSizing2 2353 * array tests, and attempts to compile each test shader, for both 2354 * vertex and fragment shaders. 2355 * 2356 * @tparam API Tested API descriptor 2357 * 2358 * @param tested_shader_type The type of shader that is being tested 2359 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2360 */ 2361 template <class API> 2362 void ConstructorsAndUnsizedDeclConstructorSizing2<API>::test_shader_compilation( 2363 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2364 { 2365 std::string shader_source = shader_start; 2366 2367 shader_source += " float[] a =" 2368 " float[](1.0, 2.0)," 2369 " b[] =" 2370 " float[][](" 2371 " float[](1.0, 2.0)," 2372 " float[](3.0, 4.0)" 2373 " )," 2374 " c[][] =" 2375 " float[][][](" 2376 " float[][](" 2377 " float[](1.0)," 2378 " float[](2.0)" 2379 " )" 2380 " )," 2381 " d[][][] =" 2382 " float[][][][](" 2383 " float[][][](" 2384 " float[][](" 2385 " float[](1.0, 2.0)," 2386 " float[](3.0, 4.0)," 2387 " float[](5.0, 6.0)" 2388 " )" 2389 " )," 2390 " float[][][](" 2391 " float[][](" 2392 " float[](1.0, 2.0)," 2393 " float[](3.0, 4.0)," 2394 " float[](5.0, 6.0)" 2395 " )" 2396 " )" 2397 " )," 2398 " e[][][][]=" 2399 " float[][][][][](" 2400 " float[][][][](" 2401 " float[][][](" 2402 " float[][](" 2403 " float[](1.0)," 2404 " float[](2.0)" 2405 " )," 2406 " float[][](" 2407 " float[](1.0)," 2408 " float[](2.0)" 2409 " )," 2410 " float[][](" 2411 " float[](1.0)," 2412 " float[](2.0)" 2413 " )" 2414 " )," 2415 " float[][][](" 2416 " float[][](" 2417 " float[](1.0)," 2418 " float[](2.0)" 2419 " )," 2420 " float[][](" 2421 " float[](1.0)," 2422 " float[](2.0)" 2423 " )," 2424 " float[][](" 2425 " float[](1.0)," 2426 " float[](2.0)" 2427 " )" 2428 " )" 2429 " )" 2430 " )," 2431 " f[][][][][]=" 2432 " float[][][][][][](" 2433 " float[][][][][](" 2434 " float[][][][](" 2435 " float[][][](" 2436 " float[][](" 2437 " float[](1.0)" 2438 " )" 2439 " )" 2440 " )" 2441 " )" 2442 " )," 2443 " g[][][][][][]=" 2444 " float[][][][][][][](" 2445 " float[][][][][][](" 2446 " float[][][][][](" 2447 " float[][][][](" 2448 " float[][][](" 2449 " float[][](" 2450 " float[](1.0)" 2451 " )" 2452 " )" 2453 " )" 2454 " )" 2455 " )" 2456 " )," 2457 " h[][][][][][][]=" 2458 " float[][][][][][][][](" 2459 " float[][][][][][][](" 2460 " float[][][][][][](" 2461 " float[][][][][](" 2462 " float[][][][](" 2463 " float[][][](" 2464 " float[][](" 2465 " float[](1.0)" 2466 " )" 2467 " )" 2468 " )" 2469 " )" 2470 " )" 2471 " )" 2472 " );\n"; 2473 2474 /* End main */ 2475 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2476 2477 /* Execute test */ 2478 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2479 } 2480 2481 /* Constructs a suitable constructor for the specified number of dimensions. 2482 * 2483 * @tparam API Tested API descriptor 2484 * 2485 * @param var_type The type of the variable 2486 * @param dimension_index The current recursion level (counts down) 2487 * @param init_string The initialisation string 2488 */ 2489 template <class API> 2490 std::string ConstructorsAndUnsizedDeclStructConstructors<API>::recursively_initialise(std::string var_type, 2491 size_t dimension_index, 2492 std::string init_string) 2493 { 2494 std::string temp_string; 2495 2496 if (dimension_index == 0) 2497 { 2498 temp_string = var_type + "(" + init_string + ")"; 2499 } 2500 else 2501 { 2502 std::string prefix = "\n"; 2503 2504 for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++) 2505 { 2506 prefix += " "; 2507 } 2508 2509 prefix += this->extend_string(var_type, "[]", dimension_index); 2510 prefix += "("; 2511 2512 for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++) 2513 { 2514 temp_string += prefix; 2515 temp_string += recursively_initialise(var_type, dimension_index - 1, init_string); 2516 prefix = ", "; 2517 2518 if (dimension_index == 1) 2519 { 2520 break; 2521 } 2522 } 2523 temp_string += ")"; 2524 } 2525 2526 return temp_string; 2527 } 2528 2529 /* Generates the shader source code for the ConstructorsAndUnsizedDeclStructConstructors 2530 * array tests, and attempts to compile each test shader, for both 2531 * vertex and fragment shaders. 2532 * 2533 * @tparam API Tested API descriptor 2534 * 2535 * @param tested_shader_type The type of shader that is being tested 2536 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2537 */ 2538 template <class API> 2539 void ConstructorsAndUnsizedDeclStructConstructors<API>::test_shader_compilation( 2540 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2541 { 2542 std::string example_structure_definition("struct light {\n" 2543 " float intensity;\n" 2544 " int position;\n" 2545 "};\n"); 2546 std::string example_structure_object(" light my_light_variable"); 2547 2548 for (size_t max_dimension_index = 2; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 2549 { 2550 std::string base_variable_string = this->extend_string(example_structure_object, "[]", max_dimension_index); 2551 base_variable_string += " = "; 2552 base_variable_string += recursively_initialise("light", max_dimension_index, "1.0, 2"); 2553 base_variable_string += ";\n\n"; 2554 2555 std::string shader_source = example_structure_definition + shader_start + base_variable_string; 2556 2557 /* End main */ 2558 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2559 2560 /* Execute test */ 2561 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2562 } /* for (int max_dimension_index = 2; ...) */ 2563 } 2564 2565 /* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays1 2566 * array tests, and attempts to compile each test shader, for both 2567 * vertex and fragment shaders. 2568 * 2569 * @tparam API Tested API descriptor 2570 * 2571 * @param tested_shader_type The type of shader that is being tested 2572 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2573 */ 2574 template <class API> 2575 void ConstructorsAndUnsizedDeclUnsizedArrays1<API>::test_shader_compilation( 2576 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2577 { 2578 std::string base_variable_string; 2579 2580 for (size_t max_dimension_index = 2; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 2581 { 2582 base_variable_string = this->extend_string(" int x", "[]", max_dimension_index); 2583 base_variable_string += ";\n\n"; 2584 2585 std::string shader_source = shader_start + base_variable_string; 2586 2587 /* End main */ 2588 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2589 2590 /* Execute test */ 2591 this->execute_negative_test(tested_shader_type, shader_source); 2592 } /* for (int max_dimension_index = 2; ...) */ 2593 } 2594 2595 /* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays2 2596 * array tests, and attempts to compile each test shader, for both 2597 * vertex and fragment shaders. 2598 * 2599 * @tparam API Tested API descriptor 2600 * 2601 * @param tested_shader_type The type of shader that is being tested 2602 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2603 */ 2604 template <class API> 2605 void ConstructorsAndUnsizedDeclUnsizedArrays2<API>::test_shader_compilation( 2606 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2607 { 2608 std::string input[] = { " float [] x = float[](1), y;\n\n" }; 2609 2610 for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++) 2611 { 2612 std::string shader_source; 2613 2614 shader_source += shader_start; 2615 shader_source += input[string_index]; 2616 2617 /* End main */ 2618 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2619 2620 /* Execute test */ 2621 EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION, tested_shader_type, shader_source); 2622 } /* for (int string_index = 0; ...) */ 2623 } 2624 2625 /* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays3 2626 * array tests, and attempts to compile each test shader, for both 2627 * vertex and fragment shaders. 2628 * 2629 * @tparam API Tested API descriptor 2630 * 2631 * @param tested_shader_type The type of shader that is being tested 2632 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2633 */ 2634 template <class API> 2635 void ConstructorsAndUnsizedDeclUnsizedArrays3<API>::test_shader_compilation( 2636 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2637 { 2638 std::string base_variable_string(" float[][] x = mat4(0);\n\n"); 2639 2640 std::string shader_source = shader_start + base_variable_string; 2641 2642 /* End main */ 2643 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2644 2645 /* Execute test */ 2646 this->execute_negative_test(tested_shader_type, shader_source); 2647 } 2648 2649 /* Generates the shader source code for the ConstructorsAndUnsizedDeclUnsizedArrays4 2650 * array tests, and attempts to compile each test shader, for both 2651 * vertex and fragment shaders. 2652 * 2653 * @tparam API Tested API descriptor 2654 * 2655 * @param tested_shader_type The type of shader that is being tested 2656 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2657 */ 2658 template <class API> 2659 void ConstructorsAndUnsizedDeclUnsizedArrays4<API>::test_shader_compilation( 2660 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2661 { 2662 std::string example_struct("struct light {\n" 2663 " float[][] intensity;\n" 2664 " int position;\n" 2665 "} myLight;\n\n"); 2666 2667 std::string shader_source = example_struct + shader_start; 2668 2669 /* End main */ 2670 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2671 2672 /* Execute test */ 2673 this->execute_negative_test(tested_shader_type, shader_source); 2674 } 2675 2676 /* Constructs a suitable constructor for the specified number of dimensions. 2677 * 2678 * @tparam API Tested API descriptor 2679 * 2680 * @param dimension_index The current recursion level (counts down) 2681 * @param init_string The initialisation string 2682 */ 2683 template <class API> 2684 std::string ExpressionsAssignment1<API>::recursively_initialise(std::string var_type, size_t dimension_index, 2685 std::string init_string) 2686 { 2687 std::string temp_string; 2688 2689 if (dimension_index == 0) 2690 { 2691 temp_string = init_string; 2692 } 2693 else 2694 { 2695 std::string prefix = "\n"; 2696 2697 for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++) 2698 { 2699 prefix += " "; 2700 } 2701 2702 prefix += this->extend_string(var_type, "[]", dimension_index); 2703 prefix += "("; 2704 for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++) 2705 { 2706 temp_string += prefix; 2707 temp_string += recursively_initialise(var_type, dimension_index - 1, init_string); 2708 prefix = ", "; 2709 if (dimension_index == 1) 2710 { 2711 break; 2712 } 2713 } 2714 temp_string += ")"; 2715 } 2716 2717 return temp_string; 2718 } 2719 2720 /* Generates the shader source code for the ExpressionsAssignment1 2721 * array tests, and attempts to compile each test shader, for both 2722 * vertex and fragment shaders. 2723 * 2724 * @tparam API Tested API descriptor 2725 * 2726 * @param tested_shader_type The type of shader that is being tested 2727 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2728 */ 2729 template <class API> 2730 void ExpressionsAssignment1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 2731 { 2732 for (size_t max_dimension_index = 2; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 2733 { 2734 std::string prefix = "("; 2735 std::string base_variable_string; 2736 2737 base_variable_string += this->extend_string(" float x", "[2]", max_dimension_index); 2738 base_variable_string += " = "; 2739 base_variable_string += recursively_initialise("float", max_dimension_index, "4.0, 6.0"); 2740 base_variable_string += ";\n"; 2741 base_variable_string += this->extend_string(" float y", "[2]", max_dimension_index); 2742 base_variable_string += " = "; 2743 base_variable_string += recursively_initialise("float", max_dimension_index, "1.0, 2.0"); 2744 base_variable_string += ";\n\n"; 2745 2746 std::string shader_source = shader_start + base_variable_string; 2747 2748 shader_source += " x = y;\n"; 2749 2750 /* End main */ 2751 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2752 2753 /* Execute test */ 2754 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2755 } /* for (int max_dimension_index = 2; ...) */ 2756 } 2757 2758 /* Generates the shader source code for the ExpressionsAssignment2 2759 * array tests, and attempts to compile each test shader, for both 2760 * vertex and fragment shaders. 2761 * 2762 * @tparam API Tested API descriptor 2763 * 2764 * @param tested_shader_type The type of shader that is being tested 2765 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2766 */ 2767 template <class API> 2768 void ExpressionsAssignment2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 2769 { 2770 std::string shader_body(" float a[2] = float[](1.0, 2.0);\n" 2771 " float b[2][2] = float[][](float[](1.0, 2.0), float[](1.0, 2.0));\n" 2772 " float c[2][2][2] = float[][][](" 2773 "float[][](float[](1.0, 2.0), float[](1.0, 2.0))," 2774 "float[][](float[](1.0, 2.0), float[](1.0, 2.0)));\n" 2775 " float d[2][2][2][2] = float[][][][](" 2776 "float[][][](" 2777 "float[][](float[](1.0, 2.0), float[](1.0, 2.0)), " 2778 "float[][](float[](1.0, 2.0), float[](1.0, 2.0)))," 2779 "float[][][](" 2780 "float[][](float[](1.0, 2.0), float[](1.0, 2.0)), " 2781 "float[][](float[](1.0, 2.0), float[](1.0, 2.0))));\n\n"); 2782 2783 std::string variable_basenames[] = { "a", "b", "c", "d" }; 2784 int number_of_elements = sizeof(variable_basenames) / sizeof(variable_basenames[0]); 2785 2786 for (int variable_index = 0; variable_index < number_of_elements; variable_index++) 2787 { 2788 for (int value_index = variable_index; value_index < number_of_elements; value_index++) 2789 { 2790 std::string shader_source = shader_start + shader_body; 2791 2792 /* Avoid the situation when a variable is assign to itself. */ 2793 if (variable_index != value_index) 2794 { 2795 shader_source += " " + variable_basenames[variable_index] + " = " + variable_basenames[value_index]; 2796 shader_source += ";\n"; 2797 2798 /* End main */ 2799 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2800 2801 /* Execute test */ 2802 this->execute_negative_test(tested_shader_type, shader_source); 2803 } /* if(variable_index != value_index) */ 2804 } /* for (int value_index = variable_index; ...) */ 2805 } /* for (int variable_index = 0; ...) */ 2806 } 2807 2808 /* Generates the shader source code for the ExpressionsAssignment3 2809 * array tests, and attempts to compile each test shader, for both 2810 * vertex and fragment shaders. 2811 * 2812 * @tparam API Tested API descriptor 2813 * 2814 * @param tested_shader_type The type of shader that is being tested 2815 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2816 */ 2817 template <class API> 2818 void ExpressionsAssignment3<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 2819 { 2820 std::string prefix, base_variable_string; 2821 2822 const int test_array_dimensions = 4; 2823 2824 prefix = this->extend_string(" float a", "[1]", 4); 2825 prefix += " = float[][][][](\n" 2826 " float[][][](\n" 2827 " float[][](\n" 2828 " float[](1.0))));\n"; 2829 2830 prefix += " float b"; 2831 2832 for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++) 2833 { 2834 base_variable_string = prefix; 2835 2836 for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--) 2837 { 2838 if (permutation & (1 << sub_script_index)) 2839 { 2840 base_variable_string += "[1]"; 2841 } 2842 else 2843 { 2844 base_variable_string += "[2]"; 2845 } 2846 } 2847 2848 base_variable_string += ";\n\n"; 2849 2850 if (permutation != (1 << test_array_dimensions) - 1) 2851 { 2852 std::string shader_source = shader_start + base_variable_string; 2853 2854 shader_source += " b = a;\n"; 2855 2856 /* End main */ 2857 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2858 2859 /* Execute test */ 2860 this->execute_negative_test(tested_shader_type, shader_source); 2861 } /* if (permutation != (1 << test_array_dimensions) - 1) */ 2862 } /* for (int permutation = 0; ...) */ 2863 } 2864 2865 /* Generates the shader source code for the ExpressionsTypeRestrictions1 2866 * array tests, and attempts to compile each test shader, for both 2867 * vertex and fragment shaders. 2868 * 2869 * @tparam API Tested API descriptor 2870 * 2871 * @param tested_shader_type The type of shader that is being tested 2872 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2873 */ 2874 template <class API> 2875 void ExpressionsTypeRestrictions1<API>::test_shader_compilation( 2876 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2877 { 2878 int num_var_types = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]); 2879 2880 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 2881 { 2882 _supported_variable_types_map_const_iterator var_iterator = 2883 supported_variable_types_map.find(opaque_var_types[var_type_index]); 2884 2885 if (var_iterator != supported_variable_types_map.end()) 2886 { 2887 std::string shader_source = 2888 "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " var1[2][2];\n" 2889 "uniform " + 2890 var_iterator->second.precision + " " + var_iterator->second.type + " var2[2][2];\n\n"; 2891 shader_source += shader_start; 2892 2893 shader_source += " var1 = var2;\n"; 2894 2895 /* End main */ 2896 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2897 2898 /* Execute test */ 2899 this->execute_negative_test(tested_shader_type, shader_source); 2900 } /* if var_type iterator found */ 2901 else 2902 { 2903 TCU_FAIL("Type not found."); 2904 } 2905 } /* for (int var_type_index = 0; ...) */ 2906 } 2907 2908 /* Generates the shader source code for the ExpressionsTypeRestrictions2 2909 * array tests, and attempts to compile each test shader, for both 2910 * vertex and fragment shaders. 2911 * 2912 * @tparam API Tested API descriptor 2913 * 2914 * @param tested_shader_type The type of shader that is being tested 2915 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2916 */ 2917 template <class API> 2918 void ExpressionsTypeRestrictions2<API>::test_shader_compilation( 2919 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2920 { 2921 int num_var_types = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]); 2922 2923 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 2924 { 2925 _supported_variable_types_map_const_iterator var_iterator = 2926 supported_variable_types_map.find(opaque_var_types[var_type_index]); 2927 2928 if (var_iterator != supported_variable_types_map.end()) 2929 { 2930 std::string shader_source = 2931 "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " sampler1;\n" 2932 "uniform " + 2933 var_iterator->second.precision + " " + var_iterator->second.type + " sampler2;\n" 2934 "uniform " + 2935 var_iterator->second.precision + " " + var_iterator->second.type + " sampler3;\n" 2936 "uniform " + 2937 var_iterator->second.precision + " " + var_iterator->second.type + " sampler4;\n" 2938 "struct light1 {\n" 2939 " " + 2940 var_iterator->second.type + " var1[2][2];\n" 2941 "};\n\n"; 2942 shader_source += shader_start; 2943 2944 shader_source += 2945 (" light1 x = light1(" + var_iterator->second.type + "[][](" + var_iterator->second.type + 2946 "[](sampler1, sampler2), " + var_iterator->second.type + "[](sampler3, sampler4)));\n"); 2947 shader_source += " light1 y = x;\n\n"; 2948 2949 /* End main */ 2950 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2951 2952 /* Execute test */ 2953 this->execute_negative_test(tested_shader_type, shader_source); 2954 } /* if var_type iterator found */ 2955 else 2956 { 2957 TCU_FAIL("Type not found."); 2958 } 2959 } /* for (int var_type_index = 0; ...) */ 2960 } 2961 2962 /* Generates the shader source code for the ExpressionsIndexingScalar1 2963 * array tests, and attempts to compile each test shader, for both 2964 * vertex and fragment shaders. 2965 * 2966 * @tparam API Tested API descriptor 2967 * 2968 * @param tested_shader_type The type of shader that is being tested 2969 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 2970 */ 2971 template <class API> 2972 void ExpressionsIndexingScalar1<API>::test_shader_compilation( 2973 typename TestCaseBase<API>::TestShaderType tested_shader_type) 2974 { 2975 for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++) 2976 { 2977 _supported_variable_types_map_const_iterator var_iterator = 2978 supported_variable_types_map.find(API::var_types[var_type_index]); 2979 2980 if (var_iterator != supported_variable_types_map.end()) 2981 { 2982 std::string shader_source = shader_start + " " + var_iterator->second.type + " x[1][2][3][4];\n\n"; 2983 2984 shader_source += " for (uint i = 0u; i < 2u; i++) {\n"; 2985 shader_source += " for (uint j = 0u; j < 3u; j++) {\n"; 2986 shader_source += " for (uint k = 0u; k < 4u; k++) {\n"; 2987 shader_source += " x[0][i][j][k] = " + var_iterator->second.initializer_with_ones + ";\n"; 2988 shader_source += " }\n"; 2989 shader_source += " }\n"; 2990 shader_source += " }\n"; 2991 2992 /* End main */ 2993 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 2994 2995 /* Execute test */ 2996 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 2997 } /* if var_type iterator found */ 2998 else 2999 { 3000 TCU_FAIL("Type not found."); 3001 } 3002 } 3003 } 3004 3005 /* Generates the shader source code for the ExpressionsIndexingScalar2 3006 * array tests, and attempts to compile each test shader, for both 3007 * vertex and fragment shaders. 3008 * 3009 * @tparam API Tested API descriptor 3010 * 3011 * @param tested_shader_type The type of shader that is being tested 3012 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3013 */ 3014 template <class API> 3015 void ExpressionsIndexingScalar2<API>::test_shader_compilation( 3016 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3017 { 3018 std::string base_shader_string, shader_source; 3019 3020 // This test tests arrays with 4 dimensions, e.g. x[1][1][1][1] 3021 const int test_array_dimensions = 4; 3022 3023 base_shader_string = "float a[1][2][3][4];\n"; 3024 base_shader_string += "float b = 2.0;\n\n"; 3025 base_shader_string += shader_start; 3026 3027 // There are 16 permutations, so loop 4x4 times. 3028 for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++) 3029 { 3030 shader_source = base_shader_string + " a"; // a var called 'a' 3031 3032 for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--) 3033 { 3034 /* If any bit is set for a particular number then add 3035 * a valid array sub_script at that place, otherwise 3036 * add an invalid array sub_script. */ 3037 if (permutation & (1 << sub_script_index)) 3038 { 3039 shader_source += "[0]"; 3040 } 3041 else 3042 { 3043 shader_source += "[-1]"; 3044 } 3045 } 3046 3047 shader_source += " = b;\n"; 3048 3049 if (permutation != (1 << test_array_dimensions) - 1) 3050 { 3051 /* End main */ 3052 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3053 3054 /* Execute test */ 3055 this->execute_negative_test(tested_shader_type, shader_source); 3056 } /* if (permutation != (1 << test_array_dimensions) - 1) */ 3057 } /* for (int permutation = 0; ...) */ 3058 } 3059 3060 /* Generates the shader source code for the ExpressionsIndexingScalar3 3061 * array tests, and attempts to compile each test shader, for both 3062 * vertex and fragment shaders. 3063 * 3064 * @tparam API Tested API descriptor 3065 * 3066 * @param tested_shader_type The type of shader that is being tested 3067 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3068 */ 3069 template <class API> 3070 void ExpressionsIndexingScalar3<API>::test_shader_compilation( 3071 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3072 { 3073 std::string base_shader_string; 3074 std::string shader_source; 3075 const int test_array_dimensions = 4; 3076 3077 base_shader_string = "float a[1][2][3][4];\n"; 3078 base_shader_string += "float b = 2.0;\n\n"; 3079 base_shader_string += shader_start; 3080 3081 for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++) 3082 { 3083 shader_source = base_shader_string + " a"; 3084 3085 for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--) 3086 { 3087 if (permutation & (1 << sub_script_index)) 3088 { 3089 shader_source += "[0]"; 3090 } 3091 else 3092 { 3093 shader_source += "[4]"; 3094 } 3095 } 3096 3097 shader_source += " = b;\n"; 3098 3099 if (permutation != (1 << test_array_dimensions) - 1) 3100 { 3101 /* End main */ 3102 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3103 3104 /* Execute test */ 3105 this->execute_negative_test(tested_shader_type, shader_source); 3106 } /* if (permutation != (1 << test_array_dimensions) - 1) */ 3107 } /* for (int permutation = 0; ...) */ 3108 } 3109 3110 /* Generates the shader source code for the ExpressionsIndexingScalar4 3111 * array tests, and attempts to compile each test shader, for both 3112 * vertex and fragment shaders. 3113 * 3114 * @tparam API Tested API descriptor 3115 * 3116 * @param tested_shader_type The type of shader that is being tested 3117 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3118 */ 3119 template <class API> 3120 void ExpressionsIndexingScalar4<API>::test_shader_compilation( 3121 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3122 { 3123 std::string base_shader_string; 3124 std::string shader_source; 3125 3126 const int test_array_dimensions = 4; 3127 3128 base_shader_string = "float a[1][2][3][4];\n"; 3129 base_shader_string += "float b = 2.0;\n\n"; 3130 base_shader_string += shader_start; 3131 3132 for (int permutation = 0; permutation < (1 << test_array_dimensions); permutation++) 3133 { 3134 shader_source = base_shader_string + " a"; 3135 3136 for (int sub_script_index = test_array_dimensions - 1; sub_script_index >= 0; sub_script_index--) 3137 { 3138 if (permutation & (1 << sub_script_index)) 3139 { 3140 shader_source += "[0]"; 3141 } 3142 else 3143 { 3144 shader_source += "[]"; 3145 } 3146 } 3147 3148 shader_source += " = b;\n"; 3149 3150 if (permutation != (1 << test_array_dimensions) - 1) 3151 { 3152 /* End main */ 3153 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3154 3155 /* Execute test */ 3156 this->execute_negative_test(tested_shader_type, shader_source); 3157 } /* if (permutation != (1 << test_array_dimensions) - 1) */ 3158 } /* for (int permutation = 0; ...) */ 3159 } 3160 3161 /* Generates the shader source code for the ExpressionsIndexingArray1 3162 * array tests, and attempts to compile each test shader, for both 3163 * vertex and fragment shaders. 3164 * 3165 * @tparam API Tested API descriptor 3166 * 3167 * @param tested_shader_type The type of shader that is being tested 3168 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3169 */ 3170 template <class API> 3171 void ExpressionsIndexingArray1<API>::test_shader_compilation( 3172 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3173 { 3174 std::string shader_source; 3175 std::string variable_declaration = "float x[1][1][1][1][1][1][1][1];\n\n"; 3176 3177 std::string variable_initializations[] = { 3178 "x[0] = float[1][1][1][1][1][1][1](" 3179 "float[1][1][1][1][1][1](float[1][1][1][1][1](float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0)))))));" 3180 "\n", 3181 "x[0][0] = " 3182 "float[1][1][1][1][1][1](float[1][1][1][1][1](float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0))))));" 3183 "\n", 3184 "x[0][0][0] = " 3185 "float[1][1][1][1][1](float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0)))));\n", 3186 "x[0][0][0][0] = float[1][1][1][1](float[1][1][1](float[1][1](float[1](1.0))));\n", 3187 "x[0][0][0][0][0] = float[1][1][1](float[1][1](float[1](1.0)));\n", 3188 "x[0][0][0][0][0][0] = float[1][1](float[1](1.0));\n", "x[0][0][0][0][0][0][0] = float[1](1.0);\n", 3189 "x[0][0][0][0][0][0][0][0] = 1.0;\n" 3190 }; 3191 3192 for (size_t string_index = 0; string_index < sizeof(variable_initializations) / sizeof(variable_initializations[0]); 3193 string_index++) 3194 { 3195 shader_source = variable_declaration + shader_start; 3196 shader_source += " " + variable_initializations[string_index]; 3197 3198 /* End main */ 3199 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3200 3201 /* Execute test */ 3202 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 3203 } /* for (int string_index = 0; ...) */ 3204 } 3205 3206 /* Constructs a suitable constructor for the specified number of dimensions. 3207 * 3208 * @tparam API Tested API descriptor 3209 * 3210 * @param dimension_index The current recursion level (counts down) 3211 * @param init_string The initialisation string 3212 */ 3213 template <class API> 3214 std::string ExpressionsIndexingArray2<API>::recursively_initialise(std::string var_type, size_t dimension_index, 3215 std::string init_string) 3216 { 3217 std::string temp_string; 3218 3219 if (dimension_index == 0) 3220 { 3221 temp_string = init_string; 3222 } 3223 else 3224 { 3225 std::string prefix = "\n"; 3226 3227 for (size_t indent_index = dimension_index; indent_index < (API::MAX_ARRAY_DIMENSIONS + 1); indent_index++) 3228 { 3229 prefix += " "; 3230 } 3231 3232 prefix += this->extend_string(var_type, "[]", dimension_index); 3233 prefix += "("; 3234 for (int sub_script_index = 0; sub_script_index < 2; sub_script_index++) 3235 { 3236 temp_string += prefix; 3237 temp_string += recursively_initialise(var_type, dimension_index - 1, init_string); 3238 prefix = ", "; 3239 if (dimension_index == 1) 3240 { 3241 break; 3242 } 3243 } 3244 temp_string += ")"; 3245 } 3246 3247 return temp_string; 3248 } 3249 3250 /* Generates the shader source code for the ExpressionsIndexingArray2 3251 * array tests, and attempts to compile each test shader, for both 3252 * vertex and fragment shaders. 3253 * 3254 * @tparam API Tested API descriptor 3255 * 3256 * @param tested_shader_type The type of shader that is being tested 3257 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3258 */ 3259 template <class API> 3260 void ExpressionsIndexingArray2<API>::test_shader_compilation( 3261 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3262 { 3263 std::string variable_initialiser = " float[](float[](float(float(float(float(float(float(1.0))))))));\n"; 3264 3265 std::string x_variable_initializaton = 3266 " float x[2][2][2][2][2][2][2][1] = " + recursively_initialise("float", API::MAX_ARRAY_DIMENSIONS, "1.0") + 3267 ";\n"; 3268 std::string y_variable_initializaton = 3269 " float y[2][2][2][2][2][2][2][1] = " + recursively_initialise("float", API::MAX_ARRAY_DIMENSIONS, "1.0") + 3270 ";\n"; 3271 3272 std::string shader_code_common_part = shader_start + x_variable_initializaton + y_variable_initializaton; 3273 3274 for (size_t max_dimension_index = 1; max_dimension_index <= API::MAX_ARRAY_DIMENSIONS; max_dimension_index++) 3275 { 3276 std::string iteration_specific_shader_code_part; 3277 3278 iteration_specific_shader_code_part += this->extend_string(" x", "[0]", max_dimension_index); 3279 iteration_specific_shader_code_part += " = "; 3280 iteration_specific_shader_code_part += this->extend_string("y", "[0]", max_dimension_index); 3281 iteration_specific_shader_code_part += ";\n"; 3282 3283 std::string shader_source = shader_code_common_part + iteration_specific_shader_code_part; 3284 3285 /* End main */ 3286 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3287 3288 /* Execute test */ 3289 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 3290 } 3291 } 3292 3293 /* Generates the shader source code for the ExpressionsIndexingArray3 3294 * array tests, and attempts to compile each test shader, for both 3295 * vertex and fragment shaders. 3296 * 3297 * @tparam API Tested API descriptor 3298 * 3299 * @param tested_shader_type The type of shader that is being tested 3300 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3301 */ 3302 template <class API> 3303 void ExpressionsIndexingArray3<API>::test_shader_compilation( 3304 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3305 { 3306 std::string input[] = { " x[ivec2(0)] = 1.0;\n\n", " x[ivec3(0)] = 1.0;\n\n", " x[ivec4(0)] = 1.0;\n\n" }; 3307 3308 for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++) 3309 { 3310 std::string shader_source = shader_start + this->extend_string(" float x", "[2]", (int)string_index + 2) + 3311 ";\n\n" + input[string_index]; 3312 3313 /* End main */ 3314 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3315 3316 /* Execute test */ 3317 this->execute_negative_test(tested_shader_type, shader_source); 3318 } /* for (int string_index = 0; ...) */ 3319 } 3320 3321 /* Generates the shader source code for the ExpressionsDynamicIndexing1 3322 * array tests, and attempts to compile each test shader, for both 3323 * vertex and fragment shaders. 3324 * 3325 * @tparam API Tested API descriptor 3326 * 3327 * @param tested_shader_type The type of shader that is being tested 3328 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3329 */ 3330 template <class API> 3331 void ExpressionsDynamicIndexing1<API>::test_shader_compilation( 3332 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3333 { 3334 std::string expression_type_declarations = "uniform int a;\n" 3335 "const int b = 0;\n" 3336 "int c = 0;\n" 3337 "float x[2][2];\n"; 3338 3339 std::string expressions[] = { "a", "b", "c", "0 + 1" }; 3340 std::string shader_source; 3341 3342 for (size_t write_index = 0; write_index < sizeof(expressions) / sizeof(expressions[0]); write_index++) 3343 { 3344 for (size_t read_index = 0; read_index < sizeof(expressions) / sizeof(expressions[0]); read_index++) 3345 { 3346 shader_source = expression_type_declarations; 3347 shader_source += shader_start; 3348 shader_source += " x["; 3349 shader_source += expressions[write_index]; 3350 shader_source += "]["; 3351 shader_source += expressions[read_index]; 3352 shader_source += "] = 1.0;\n\n"; 3353 3354 /* End main */ 3355 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3356 3357 /* Execute test */ 3358 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 3359 } /* for (int read_index = 0; ...) */ 3360 } /* for (int write_index = 0; ...) */ 3361 } 3362 3363 /* Generates the shader source code for the ExpressionsDynamicIndexing2 3364 * array tests, and attempts to compile each test shader, for both 3365 * vertex and fragment shaders. 3366 * 3367 * @tparam API Tested API descriptor 3368 * 3369 * @param tested_shader_type The type of shader that is being tested 3370 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3371 */ 3372 template <class API> 3373 void ExpressionsDynamicIndexing2<API>::test_shader_compilation( 3374 typename TestCaseBase<API>::TestShaderType tested_shader_type) 3375 { 3376 int num_var_types = sizeof(opaque_var_types) / sizeof(opaque_var_types[0]); 3377 const std::string invalid_size_declarations[] = { "[0][0][0][y]", "[0][0][y][0]", "[0][y][0][0]", "[y][0][0][0]", 3378 "[0][0][y][y]", "[0][y][0][y]", "[y][0][0][y]", "[0][y][y][0]", 3379 "[y][0][y][0]", "[y][y][0][0]", "[0][y][y][y]", "[y][0][y][y]", 3380 "[y][y][0][y]", "[y][y][y][0]", "[y][y][y][y]" }; 3381 3382 bool dynamic_indexing_supported = false; 3383 if (glu::contextSupports(this->context_id.getRenderContext().getType(), glu::ApiType::es(3, 2)) || 3384 glu::contextSupports(this->context_id.getRenderContext().getType(), glu::ApiType::core(4, 0)) || 3385 this->context_id.getContextInfo().isExtensionSupported("GL_EXT_gpu_shader5")) 3386 { 3387 dynamic_indexing_supported = true; 3388 } 3389 3390 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 3391 { 3392 _supported_variable_types_map_const_iterator var_iterator = 3393 supported_variable_types_map.find(opaque_var_types[var_type_index]); 3394 3395 if (var_iterator != supported_variable_types_map.end()) 3396 { 3397 int num_invalid_size_declarations = 3398 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]); 3399 3400 for (int invalid_size_index = 0; invalid_size_index < num_invalid_size_declarations; invalid_size_index++) 3401 { 3402 std::string shader_source = "int y = 1;\n"; 3403 3404 shader_source += "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + 3405 " x[2][2][2][2];\n\n"; 3406 shader_source += "void main()\n"; 3407 shader_source += "{\n"; 3408 shader_source += (" " + var_iterator->second.type_of_result_of_texture_function + 3409 " color = texture(x" + invalid_size_declarations[invalid_size_index] + ", " + 3410 var_iterator->second.coord_param_for_texture_function + ");\n"); 3411 3412 /* End main */ 3413 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3414 3415 if (dynamic_indexing_supported) 3416 { 3417 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, true); 3418 } 3419 else 3420 { 3421 this->execute_negative_test(tested_shader_type, shader_source); 3422 } 3423 } /* for (int invalid_size_index = 0; ...) */ 3424 } /* if var_type iterator found */ 3425 else 3426 { 3427 TCU_FAIL("Type not found."); 3428 } 3429 } /* for (int var_type_index = 0; ...) */ 3430 } 3431 3432 /* Generates the shader source code for the ExpressionsEquality1 3433 * array tests, and attempts to compile each test shader, for both 3434 * vertex and fragment shaders. 3435 * 3436 * @tparam API Tested API descriptor 3437 * 3438 * @param tested_shader_type The type of shader that is being tested 3439 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3440 */ 3441 template <class API> 3442 void ExpressionsEquality1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 3443 { 3444 int num_var_types = API::n_var_types; 3445 3446 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 3447 { 3448 _supported_variable_types_map_const_iterator var_iterator = 3449 supported_variable_types_map.find(API::var_types[var_type_index]); 3450 3451 if (var_iterator != supported_variable_types_map.end()) 3452 { 3453 std::string shader_source = shader_start; 3454 3455 shader_source += " "; 3456 shader_source += var_iterator->second.type; 3457 shader_source += "[][] x = "; 3458 shader_source += var_iterator->second.type; 3459 shader_source += "[][]("; 3460 shader_source += var_iterator->second.type; 3461 shader_source += "[]("; 3462 shader_source += var_iterator->second.initializer_with_zeroes; 3463 shader_source += ","; 3464 shader_source += var_iterator->second.initializer_with_zeroes; 3465 shader_source += "),"; 3466 shader_source += var_iterator->second.type; 3467 shader_source += "[]("; 3468 shader_source += var_iterator->second.initializer_with_zeroes; 3469 shader_source += ","; 3470 shader_source += var_iterator->second.initializer_with_zeroes; 3471 shader_source += "));\n"; 3472 shader_source += " "; 3473 shader_source += var_iterator->second.type; 3474 shader_source += "[][] y = "; 3475 shader_source += var_iterator->second.type; 3476 shader_source += "[][]("; 3477 shader_source += var_iterator->second.type; 3478 shader_source += "[]("; 3479 shader_source += var_iterator->second.initializer_with_zeroes; 3480 shader_source += ","; 3481 shader_source += var_iterator->second.initializer_with_zeroes; 3482 shader_source += "),"; 3483 shader_source += var_iterator->second.type; 3484 shader_source += "[]("; 3485 shader_source += var_iterator->second.initializer_with_zeroes; 3486 shader_source += ","; 3487 shader_source += var_iterator->second.initializer_with_zeroes; 3488 shader_source += "));\n\n"; 3489 shader_source += " float result = 0.0;\n\n"; 3490 shader_source += " if (x == y)\n"; 3491 shader_source += " {\n"; 3492 shader_source += " result = 1.0;\n"; 3493 shader_source += " }\n"; 3494 shader_source += " if (y != x)\n"; 3495 shader_source += " {\n"; 3496 shader_source += " result = 2.0;\n"; 3497 shader_source += " }\n"; 3498 3499 /* End main */ 3500 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 3501 3502 /* Execute test */ 3503 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 3504 } /* if var_type iterator found */ 3505 else 3506 { 3507 TCU_FAIL("Type not found."); 3508 } 3509 } 3510 } 3511 3512 /* Generates the shader source code for the ExpressionsEquality2 3513 * array tests, and attempts to compile each test shader, for both 3514 * vertex and fragment shaders. 3515 * 3516 * @tparam API Tested API descriptor 3517 * 3518 * @param tested_shader_type The type of shader that is being tested 3519 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3520 */ 3521 template <class API> 3522 void ExpressionsEquality2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 3523 { 3524 int num_var_types = API::n_var_types; 3525 3526 for (int var_type_index = 0; var_type_index < num_var_types; var_type_index++) 3527 { 3528 _supported_variable_types_map_const_iterator var_iterator = 3529 supported_variable_types_map.find(API::var_types[var_type_index]); 3530 3531 if (var_iterator != supported_variable_types_map.end()) 3532 { 3533 std::string shader_source = "struct light {\n float intensity;\n int position;\n};\n\n"; 3534 3535 shader_source += shader_start; 3536 shader_source += " light[][] x ="; 3537 shader_source += "light"; 3538 shader_source += "[][]("; 3539 shader_source += "light"; 3540 shader_source += "[](light(1.0, 1)),"; 3541 shader_source += "light"; 3542 shader_source += "[](light(2.0, 2)));\n\n"; 3543 shader_source += " light[][] y ="; 3544 shader_source += "light"; 3545 shader_source += "[][]("; 3546 shader_source += "light"; 3547 shader_source += "[](light(3.0, 3)),"; 3548 shader_source += "light"; 3549 shader_source += "[](light(4.0, 4)));\n\n"; 3550 shader_source += " float result = 0.0;\n\n"; 3551 shader_source += " if (x == y)\n"; 3552 shader_source += " {\n"; 3553 shader_source += " result = 1.0;\n"; 3554 shader_source += " }\n"; 3555 shader_source += " if (y != x)\n"; 3556 shader_source += " {\n"; 3557 shader_source += " result = 2.0;\n"; 3558 shader_source += " }\n"; 3559 3560 /* Apply stage specific stuff */ 3561 switch (tested_shader_type) 3562 { 3563 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 3564 shader_source += "\n gl_Position = vec4(0.0,0.0,0.0,1.0);\n"; 3565 break; 3566 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 3567 shader_source += "\n gl_FragDepth = result;\n"; 3568 break; 3569 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 3570 break; 3571 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 3572 shader_source += emit_quad; 3573 break; 3574 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 3575 shader_source += set_tesseation; 3576 break; 3577 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 3578 break; 3579 default: 3580 TCU_FAIL("Unrecognized shader type."); 3581 break; 3582 } 3583 3584 /* End main function */ 3585 shader_source += shader_end; 3586 3587 /* Execute test */ 3588 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 3589 } /* if var_type iterator found */ 3590 else 3591 { 3592 TCU_FAIL("Type not found."); 3593 } 3594 } 3595 } 3596 3597 /* Generates the shader source code for the ExpressionsLength1 3598 * array tests, and attempts to compile each test shader, for both 3599 * vertex and fragment shaders. 3600 * 3601 * @tparam API Tested API descriptor 3602 * 3603 * @param tested_shader_type The type of shader that is being tested 3604 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 3605 */ 3606 template <class API> 3607 void ExpressionsLength1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 3608 { 3609 std::string array_declaration = " int x[4][3][2][1];\n\n"; 3610 std::string case_specific_string[] = { " if (x.length() != 4) {\n" 3611 " result = 0.0f;\n }\n", 3612 " if (x[0].length() != 3) {\n" 3613 " result = 0.0f;\n }\n", 3614 " if (x[0][0].length() != 2) {\n" 3615 " result = 0.0f;\n }\n", 3616 " if (x[0][0][0].length() != 1) {\n" 3617 " result = 0.0f;\n }\n" }; 3618 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 3619 3620 for (size_t case_specific_string_index = 0; 3621 case_specific_string_index < sizeof(case_specific_string) / sizeof(case_specific_string[0]); 3622 case_specific_string_index++) 3623 { 3624 const std::string& test_snippet = case_specific_string[case_specific_string_index]; 3625 3626 if (false == test_compute) 3627 { 3628 execute_draw_test(tested_shader_type, array_declaration, test_snippet); 3629 } 3630 else 3631 { 3632 execute_dispatch_test(tested_shader_type, array_declaration, test_snippet); 3633 } 3634 3635 /* Deallocate any resources used. */ 3636 this->delete_objects(); 3637 } /* for (int case_specific_string_index = 0; ...) */ 3638 } 3639 3640 /** Executes test for compute program 3641 * 3642 * @tparam API Tested API descriptor 3643 * 3644 * @param tested_shader_type The type of shader that is being tested 3645 * @param tested_declaration Declaration used to prepare shader 3646 * @param tested_snippet Snippet used to prepare shader 3647 **/ 3648 template <class API> 3649 void ExpressionsLength1<API>::execute_dispatch_test(typename TestCaseBase<API>::TestShaderType tested_shader_type, 3650 const std::string& tested_declaration, 3651 const std::string& tested_snippet) 3652 { 3653 const std::string& compute_shader_source = 3654 prepare_compute_shader(tested_shader_type, tested_declaration, tested_snippet); 3655 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 3656 3657 this->execute_positive_test(empty_string, empty_string, empty_string, empty_string, empty_string, 3658 compute_shader_source, false, false); 3659 3660 /* We are now ready to verify whether the returned size is correct. */ 3661 unsigned char buffer[4] = { 0 }; 3662 glw::GLuint framebuffer_object_id = 0; 3663 glw::GLint location = -1; 3664 glw::GLuint texture_object_id = 0; 3665 glw::GLuint vao_id = 0; 3666 3667 gl.useProgram(this->program_object_id); 3668 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 3669 3670 gl.genTextures(1, &texture_object_id); 3671 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed."); 3672 3673 gl.bindTexture(GL_TEXTURE_2D, texture_object_id); 3674 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed."); 3675 3676 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1); 3677 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed."); 3678 3679 gl.bindImageTexture(0 /* image unit */, texture_object_id, 0 /* level */, GL_FALSE /* layered */, 0 /* layer */, 3680 GL_WRITE_ONLY, GL_RGBA8); 3681 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() failed."); 3682 3683 location = gl.getUniformLocation(this->program_object_id, "uni_image"); 3684 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed."); 3685 3686 if (-1 == location) 3687 { 3688 TCU_FAIL("Uniform is inactive"); 3689 } 3690 3691 gl.uniform1i(location, 0 /* image unit */); 3692 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed."); 3693 3694 gl.genVertexArrays(1, &vao_id); 3695 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 3696 3697 gl.bindVertexArray(vao_id); 3698 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 3699 3700 gl.dispatchCompute(1, 1, 1); 3701 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 3702 3703 gl.genFramebuffers(1, &framebuffer_object_id); 3704 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed."); 3705 3706 gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id); 3707 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed."); 3708 3709 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0); 3710 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed."); 3711 3712 gl.viewport(0, 0, 1, 1); 3713 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed."); 3714 3715 gl.readBuffer(GL_COLOR_ATTACHMENT0); 3716 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed."); 3717 3718 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); 3719 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed."); 3720 3721 if (buffer[0] != 255) 3722 { 3723 TCU_FAIL("Invalid array size was returned."); 3724 } 3725 3726 /* Delete generated objects. */ 3727 gl.deleteTextures(1, &texture_object_id); 3728 gl.deleteFramebuffers(1, &framebuffer_object_id); 3729 gl.deleteVertexArrays(1, &vao_id); 3730 GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects."); 3731 } 3732 3733 /** Executes test for draw program 3734 * 3735 * @tparam API Tested API descriptor 3736 * 3737 * @param tested_shader_type The type of shader that is being tested 3738 * @param tested_declaration Declaration used to prepare shader 3739 * @param tested_snippet Snippet used to prepare shader 3740 **/ 3741 template <class API> 3742 void ExpressionsLength1<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type, 3743 const std::string& tested_declaration, 3744 const std::string& tested_snippet) 3745 { 3746 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 3747 3748 if (API::USE_ALL_SHADER_STAGES) 3749 { 3750 const std::string& compute_shader_source = empty_string; 3751 const std::string& fragment_shader_source = 3752 this->prepare_fragment_shader(tested_shader_type, tested_declaration, tested_snippet); 3753 const std::string& geometry_shader_source = 3754 this->prepare_geometry_shader(tested_shader_type, tested_declaration, tested_snippet); 3755 const std::string& tess_ctrl_shader_source = 3756 this->prepare_tess_ctrl_shader(tested_shader_type, tested_declaration, tested_snippet); 3757 const std::string& tess_eval_shader_source = 3758 this->prepare_tess_eval_shader(tested_shader_type, tested_declaration, tested_snippet); 3759 const std::string& vertex_shader_source = 3760 this->prepare_vertex_shader(tested_shader_type, tested_declaration, tested_snippet); 3761 3762 switch (tested_shader_type) 3763 { 3764 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 3765 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 3766 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 3767 break; 3768 3769 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 3770 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 3771 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 3772 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 3773 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 3774 geometry_shader_source, fragment_shader_source, compute_shader_source, false, 3775 false); 3776 break; 3777 3778 default: 3779 TCU_FAIL("Invalid enum"); 3780 break; 3781 } 3782 } 3783 else 3784 { 3785 const std::string& fragment_shader_source = 3786 this->prepare_fragment_shader(tested_shader_type, tested_declaration, tested_snippet); 3787 const std::string& vertex_shader_source = 3788 this->prepare_vertex_shader(tested_shader_type, tested_declaration, tested_snippet); 3789 3790 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 3791 } 3792 3793 /* We are now ready to verify whether the returned size is correct. */ 3794 unsigned char buffer[4] = { 0 }; 3795 glw::GLuint framebuffer_object_id = 0; 3796 glw::GLuint texture_object_id = 0; 3797 glw::GLuint vao_id = 0; 3798 3799 gl.useProgram(this->program_object_id); 3800 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 3801 3802 gl.genTextures(1, &texture_object_id); 3803 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed."); 3804 3805 gl.bindTexture(GL_TEXTURE_2D, texture_object_id); 3806 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed."); 3807 3808 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1); 3809 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed."); 3810 3811 gl.genFramebuffers(1, &framebuffer_object_id); 3812 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed."); 3813 3814 gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id); 3815 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed."); 3816 3817 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0); 3818 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed."); 3819 3820 gl.viewport(0, 0, 1, 1); 3821 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed."); 3822 3823 gl.genVertexArrays(1, &vao_id); 3824 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 3825 3826 gl.bindVertexArray(vao_id); 3827 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 3828 3829 switch (tested_shader_type) 3830 { 3831 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */ 3832 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 3833 gl.drawArrays(GL_TRIANGLE_FAN, 0, 4); 3834 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 3835 break; 3836 3837 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 3838 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 3839 /* Tesselation patch set up */ 3840 gl.patchParameteri(GL_PATCH_VERTICES, 1); 3841 GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); 3842 3843 gl.drawArrays(GL_PATCHES, 0, 1); 3844 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 3845 break; 3846 3847 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 3848 gl.drawArrays(GL_POINTS, 0, 1); 3849 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 3850 break; 3851 3852 default: 3853 TCU_FAIL("Invalid enum"); 3854 break; 3855 } 3856 3857 gl.readBuffer(GL_COLOR_ATTACHMENT0); 3858 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed."); 3859 3860 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); 3861 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed."); 3862 3863 if (buffer[0] != 255) 3864 { 3865 TCU_FAIL("Invalid array size was returned."); 3866 } 3867 3868 /* Delete generated objects. */ 3869 gl.deleteTextures(1, &texture_object_id); 3870 gl.deleteFramebuffers(1, &framebuffer_object_id); 3871 gl.deleteVertexArrays(1, &vao_id); 3872 GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects."); 3873 } 3874 3875 /** Prepare shader 3876 * 3877 * @tparam API Tested API descriptor 3878 * 3879 * @param tested_shader_type The type of shader that is being tested 3880 * @param tested_declaration Declaration used to prepare shader 3881 * @param tested_snippet Snippet used to prepare shader 3882 **/ 3883 template <class API> 3884 std::string ExpressionsLength1<API>::prepare_compute_shader( 3885 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& tested_declaration, 3886 const std::string& tested_snippet) 3887 { 3888 std::string compute_shader_source; 3889 3890 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type) 3891 { 3892 compute_shader_source = "writeonly uniform image2D uni_image;\n" 3893 "\n" 3894 "void main()\n" 3895 "{\n" 3896 " float result = 1u;\n" 3897 "\n"; 3898 compute_shader_source += tested_declaration; 3899 compute_shader_source += tested_snippet; 3900 compute_shader_source += "\n" 3901 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n" 3902 "}\n" 3903 "\n"; 3904 } 3905 3906 return compute_shader_source; 3907 } 3908 3909 /** Prepare shader 3910 * 3911 * @tparam API Tested API descriptor 3912 * 3913 * @param tested_shader_type The type of shader that is being tested 3914 * @param tested_declaration Declaration used to prepare shader 3915 * @param tested_snippet Snippet used to prepare shader 3916 **/ 3917 template <class API> 3918 std::string ExpressionsLength1<API>::prepare_fragment_shader( 3919 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& tested_declaration, 3920 const std::string& tested_snippet) 3921 { 3922 std::string fragment_shader_source; 3923 3924 switch (tested_shader_type) 3925 { 3926 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 3927 break; 3928 3929 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 3930 fragment_shader_source = "out vec4 colour;\n" 3931 "\n" 3932 "void main()\n" 3933 "{\n"; 3934 fragment_shader_source += tested_declaration; 3935 fragment_shader_source += " float result = 1.0f;\n"; 3936 fragment_shader_source += tested_snippet; 3937 fragment_shader_source += " colour = vec4(result);\n" 3938 "}\n\n"; 3939 break; 3940 3941 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 3942 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 3943 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 3944 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 3945 fragment_shader_source = "in float fs_result;\n\n" 3946 "out vec4 colour;\n\n" 3947 "void main()\n" 3948 "{\n" 3949 " colour = vec4(fs_result);\n" 3950 "}\n" 3951 "\n"; 3952 break; 3953 3954 default: 3955 TCU_FAIL("Unrecognized shader object type."); 3956 break; 3957 } 3958 3959 return fragment_shader_source; 3960 } 3961 3962 /** Prepare shader 3963 * 3964 * @tparam API Tested API descriptor 3965 * 3966 * @param tested_shader_type The type of shader that is being tested 3967 * @param tested_declaration Declaration used to prepare shader 3968 * @param tested_snippet Snippet used to prepare shader 3969 **/ 3970 template <class API> 3971 std::string ExpressionsLength1<API>::prepare_geometry_shader( 3972 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& tested_declaration, 3973 const std::string& tested_snippet) 3974 { 3975 std::string geometry_shader_source; 3976 3977 switch (tested_shader_type) 3978 { 3979 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 3980 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 3981 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 3982 break; 3983 3984 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 3985 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 3986 geometry_shader_source = "layout(points) in;\n" 3987 "layout(triangle_strip, max_vertices = 4) out;\n" 3988 "\n" 3989 "in float tes_result[];\n" 3990 "out float fs_result;\n" 3991 "\n" 3992 "void main()\n" 3993 "{\n" 3994 " gl_Position = vec4(-1, -1, 0, 1);\n" 3995 " fs_result = tes_result[0];\n" 3996 " EmitVertex();\n" 3997 " gl_Position = vec4(-1, 1, 0, 1);\n" 3998 " fs_result = tes_result[0];\n" 3999 " EmitVertex();\n" 4000 " gl_Position = vec4(1, -1, 0, 1);\n" 4001 " fs_result = tes_result[0];\n" 4002 " EmitVertex();\n" 4003 " gl_Position = vec4(1, 1, 0, 1);\n" 4004 " fs_result = tes_result[0];\n" 4005 " EmitVertex();\n" 4006 "}\n"; 4007 break; 4008 4009 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4010 geometry_shader_source = "layout(points) in;\n" 4011 "layout(triangle_strip, max_vertices = 4) out;\n" 4012 "\n" 4013 "out float fs_result;\n" 4014 "\n" 4015 "void main()\n" 4016 "{\n"; 4017 geometry_shader_source += tested_declaration; 4018 geometry_shader_source += " float result = 1.0;\n\n"; 4019 geometry_shader_source += tested_snippet; 4020 geometry_shader_source += "\n gl_Position = vec4(-1, -1, 0, 1);\n" 4021 " fs_result = result;\n" 4022 " EmitVertex();\n" 4023 " gl_Position = vec4(-1, 1, 0, 1);\n" 4024 " fs_result = result;\n" 4025 " EmitVertex();\n" 4026 " gl_Position = vec4(1, -1, 0, 1);\n" 4027 " fs_result = result;\n" 4028 " EmitVertex();\n" 4029 " gl_Position = vec4(1, 1, 0, 1);\n" 4030 " fs_result = result;\n" 4031 " EmitVertex();\n" 4032 "}\n"; 4033 break; 4034 4035 default: 4036 TCU_FAIL("Unrecognized shader object type."); 4037 break; 4038 } 4039 4040 return geometry_shader_source; 4041 } 4042 4043 /** Prepare shader 4044 * 4045 * @tparam API Tested API descriptor 4046 * 4047 * @param tested_shader_type The type of shader that is being tested 4048 * @param tested_declaration Declaration used to prepare shader 4049 * @param tested_snippet Snippet used to prepare shader 4050 **/ 4051 template <class API> 4052 std::string ExpressionsLength1<API>::prepare_tess_ctrl_shader( 4053 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& tested_declaration, 4054 const std::string& tested_snippet) 4055 { 4056 std::string tess_ctrl_shader_source; 4057 4058 switch (tested_shader_type) 4059 { 4060 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 4061 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 4062 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4063 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 4064 break; 4065 4066 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 4067 tess_ctrl_shader_source = "layout(vertices = 1) out;\n" 4068 "\n" 4069 "out float tcs_result[];\n" 4070 "\n" 4071 "void main()\n" 4072 "{\n"; 4073 tess_ctrl_shader_source += tested_declaration; 4074 tess_ctrl_shader_source += " float result = 1.0;\n\n"; 4075 tess_ctrl_shader_source += tested_snippet; 4076 tess_ctrl_shader_source += " tcs_result[gl_InvocationID] = result;\n" 4077 "\n" 4078 " gl_TessLevelOuter[0] = 1.0;\n" 4079 " gl_TessLevelOuter[1] = 1.0;\n" 4080 " gl_TessLevelOuter[2] = 1.0;\n" 4081 " gl_TessLevelOuter[3] = 1.0;\n" 4082 " gl_TessLevelInner[0] = 1.0;\n" 4083 " gl_TessLevelInner[1] = 1.0;\n" 4084 "}\n"; 4085 break; 4086 4087 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4088 tess_ctrl_shader_source = default_tc_shader_source; 4089 break; 4090 4091 default: 4092 TCU_FAIL("Unrecognized shader object type."); 4093 break; 4094 } 4095 4096 return tess_ctrl_shader_source; 4097 } 4098 4099 /** Prepare shader 4100 * 4101 * @tparam API Tested API descriptor 4102 * 4103 * @param tested_shader_type The type of shader that is being tested 4104 * @param tested_declaration Declaration used to prepare shader 4105 * @param tested_snippet Snippet used to prepare shader 4106 **/ 4107 template <class API> 4108 std::string ExpressionsLength1<API>::prepare_tess_eval_shader( 4109 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& tested_declaration, 4110 const std::string& tested_snippet) 4111 { 4112 std::string tess_eval_shader_source; 4113 4114 switch (tested_shader_type) 4115 { 4116 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 4117 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 4118 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4119 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 4120 break; 4121 4122 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 4123 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 4124 "\n" 4125 "in float tcs_result[];\n" 4126 "out float tes_result;\n" 4127 "\n" 4128 "void main()\n" 4129 "{\n" 4130 " tes_result = tcs_result[0];\n" 4131 "}\n"; 4132 break; 4133 4134 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4135 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 4136 "\n" 4137 "out float tes_result;\n" 4138 "\n" 4139 "void main()\n" 4140 "{\n"; 4141 tess_eval_shader_source += tested_declaration; 4142 tess_eval_shader_source += " float result = 1.0;\n\n"; 4143 tess_eval_shader_source += tested_snippet; 4144 tess_eval_shader_source += " tes_result = result;\n" 4145 "}\n"; 4146 break; 4147 4148 default: 4149 TCU_FAIL("Unrecognized shader object type."); 4150 break; 4151 } 4152 4153 return tess_eval_shader_source; 4154 } 4155 4156 /** Prepare shader 4157 * 4158 * @tparam API Tested API descriptor 4159 * 4160 * @param tested_shader_type The type of shader that is being tested 4161 * @param tested_declaration Declaration used to prepare shader 4162 * @param tested_snippet Snippet used to prepare shader 4163 **/ 4164 template <class API> 4165 std::string ExpressionsLength1<API>::prepare_vertex_shader( 4166 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& tested_declaration, 4167 const std::string& tested_snippet) 4168 { 4169 std::string vertex_shader_source; 4170 4171 switch (tested_shader_type) 4172 { 4173 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 4174 break; 4175 4176 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 4177 vertex_shader_source = "/** GL_TRIANGLE_FAN-type quad vertex data. */\n" 4178 "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n" 4179 " vec4(-1.0, -1.0, 0.0, 1.0),\n" 4180 " vec4(-1.0, 1.0, 0.0, 1.0),\n" 4181 " vec4( 1.0, 1.0, 0.0, 1.0) );\n" 4182 "\n" 4183 "void main()\n" 4184 "{\n" 4185 " gl_Position = vertex_positions[gl_VertexID];" 4186 "}\n\n"; 4187 break; 4188 4189 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4190 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 4191 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4192 vertex_shader_source = default_vertex_shader_source; 4193 break; 4194 4195 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 4196 vertex_shader_source = "out float fs_result;\n" 4197 "\n" 4198 "/** GL_TRIANGLE_FAN-type quad vertex data. */\n" 4199 "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n" 4200 " vec4(-1.0, -1.0, 0.0, 1.0),\n" 4201 " vec4(-1.0, 1.0, 0.0, 1.0),\n" 4202 " vec4( 1.0, 1.0, 0.0, 1.0) );\n" 4203 "\n" 4204 "void main()\n" 4205 "{\n"; 4206 vertex_shader_source += tested_declaration; 4207 vertex_shader_source += " float result = 1.0;\n\n"; 4208 vertex_shader_source += tested_snippet; 4209 vertex_shader_source += " gl_Position = vertex_positions[gl_VertexID];\n" 4210 " fs_result = result;\n"; 4211 vertex_shader_source += shader_end; 4212 break; 4213 4214 default: 4215 TCU_FAIL("Unrecognized shader object type."); 4216 break; 4217 } 4218 4219 return vertex_shader_source; 4220 } 4221 4222 /* Generates the shader source code for the ExpressionsLength2 4223 * array tests, and attempts to compile each test shader, for both 4224 * vertex and fragment shaders. 4225 * 4226 * @tparam API Tested API descriptor 4227 * 4228 * @param tested_shader_type The type of shader that is being tested 4229 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 4230 */ 4231 template <class API> 4232 void ExpressionsLength2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 4233 { 4234 std::string array_declaration = " int x[1][2][3][4];\n\n"; 4235 std::string case_specific_string[] = { " if (x.length() != 1) {\n" 4236 " result = 0.0f;\n }\n", 4237 " if (x[0].length() != 2) {\n" 4238 " result = 0.0f;\n }\n", 4239 " if (x[0][0].length() != 3) {\n" 4240 " result = 0.0f;\n }\n", 4241 " if (x[0][0][0].length() != 4) {\n" 4242 " result = 0.0f;\n }\n" }; 4243 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 4244 4245 for (size_t case_specific_string_index = 0; 4246 case_specific_string_index < sizeof(case_specific_string) / sizeof(case_specific_string[0]); 4247 case_specific_string_index++) 4248 { 4249 const std::string& test_snippet = case_specific_string[case_specific_string_index]; 4250 4251 if (false == test_compute) 4252 { 4253 this->execute_draw_test(tested_shader_type, array_declaration, test_snippet); 4254 } 4255 else 4256 { 4257 this->execute_dispatch_test(tested_shader_type, array_declaration, test_snippet); 4258 } 4259 4260 /* Deallocate any resources used. */ 4261 this->delete_objects(); 4262 } /* for (int case_specific_string_index = 0; ...) */ 4263 } 4264 4265 /* Generates the shader source code for the ExpressionsLength3 4266 * array tests, and attempts to compile each test shader, for both 4267 * vertex and fragment shaders. 4268 * 4269 * @tparam API Tested API descriptor 4270 * 4271 * @param tested_shader_type The type of shader that is being tested 4272 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 4273 */ 4274 template <class API> 4275 void ExpressionsLength3<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 4276 { 4277 std::string array_declaration = " int x[1][1][1][1];\n\n"; 4278 std::string input[] = { " if (x[].length() != 2) {\n" 4279 " result = 0.0f;\n }\n", 4280 " if (x[][].length() != 2) {\n" 4281 " result = 0.0f;\n }\n", 4282 " if (x[][][].length() != 2) {\n" 4283 " result = 0.0f;\n }\n" }; 4284 4285 for (size_t string_index = 0; string_index < sizeof(input) / sizeof(input[0]); string_index++) 4286 { 4287 std::string shader_source; 4288 const std::string& test_snippet = input[string_index]; 4289 4290 switch (tested_shader_type) 4291 { 4292 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 4293 shader_source = this->prepare_vertex_shader(tested_shader_type, array_declaration, test_snippet); 4294 break; 4295 4296 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 4297 shader_source = this->prepare_fragment_shader(tested_shader_type, array_declaration, test_snippet); 4298 break; 4299 4300 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 4301 shader_source = this->prepare_compute_shader(tested_shader_type, array_declaration, test_snippet); 4302 break; 4303 4304 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4305 shader_source = this->prepare_geometry_shader(tested_shader_type, array_declaration, test_snippet); 4306 break; 4307 4308 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 4309 shader_source = this->prepare_tess_ctrl_shader(tested_shader_type, array_declaration, test_snippet); 4310 break; 4311 4312 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4313 shader_source = this->prepare_tess_eval_shader(tested_shader_type, array_declaration, test_snippet); 4314 break; 4315 4316 default: 4317 TCU_FAIL("Unrecognized shader type."); 4318 break; 4319 } /* switch (tested_shader_type) */ 4320 4321 this->execute_negative_test(tested_shader_type, shader_source); 4322 } /* for (int string_index = 0; ...) */ 4323 } 4324 4325 /* Generates the shader source code for the ExpressionsInvalid1 4326 * array tests, and attempts to compile each test shader, for both 4327 * vertex and fragment shaders. 4328 * 4329 * @tparam API Tested API descriptor 4330 * 4331 * @param tested_shader_type The type of shader that is being tested 4332 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 4333 */ 4334 template <class API> 4335 void ExpressionsInvalid1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 4336 { 4337 std::string shader_variable_declarations = 4338 " mat2 y = mat2(0.0);\n" 4339 " float x[2][2] = float[2][2](float[2](4.0, 5.0), float[2](6.0, 7.0));\n\n"; 4340 4341 std::string shader_source = shader_start + shader_variable_declarations; 4342 4343 shader_source += " y = x;\n"; 4344 4345 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 4346 4347 this->execute_negative_test(tested_shader_type, shader_source); 4348 } 4349 4350 /* Generates the shader source code for the ExpressionsInvalid2 4351 * array tests, and attempts to compile each test shader, for both 4352 * vertex and fragment shaders. 4353 * 4354 * @tparam API Tested API descriptor 4355 * 4356 * @param tested_shader_type The type of shader that is being tested 4357 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 4358 */ 4359 template <class API> 4360 void ExpressionsInvalid2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 4361 { 4362 4363 std::string shader_variable_declarations[] = { " x", " y" }; 4364 std::string variable_relation_opeartors[] = { 4365 " float result = 0.0;\n\n if(x < y)\n {\n result = 1.0;\n }\n\n\n", 4366 " float result = 0.0;\n\n if(x <= y)\n {\n result = 1.0;\n }\n\n\n", 4367 " float result = 0.0;\n\n if(x > y)\n {\n result = 1.0;\n }\n\n\n", 4368 " float result = 0.0;\n\n if(x >= y)\n {\n result = 1.0;\n }\n\n\n" 4369 }; 4370 std::string valid_relation_opeartors = 4371 " float result = 0.0;\n\n if(x == y)\n {\n result = 1.0;\n }\n\n\n"; 4372 4373 for (size_t var_type_index = 0; var_type_index < API::n_var_types; var_type_index++) 4374 { 4375 _supported_variable_types_map_const_iterator var_iterator = 4376 supported_variable_types_map.find(API::var_types[var_type_index]); 4377 4378 if (var_iterator != supported_variable_types_map.end()) 4379 { 4380 std::string base_variable_string; 4381 4382 for (size_t variable_declaration_index = 0; 4383 variable_declaration_index < 4384 sizeof(shader_variable_declarations) / sizeof(shader_variable_declarations[0]); 4385 variable_declaration_index++) 4386 { 4387 base_variable_string += var_iterator->second.type; 4388 base_variable_string += shader_variable_declarations[variable_declaration_index]; 4389 4390 base_variable_string += "[1][1][1][1][1][1][1][1] = "; 4391 4392 for (size_t sub_script_index = 0; sub_script_index < API::MAX_ARRAY_DIMENSIONS; sub_script_index++) 4393 { 4394 base_variable_string += this->extend_string(var_iterator->second.type, "[1]", 4395 API::MAX_ARRAY_DIMENSIONS - sub_script_index); 4396 base_variable_string += "("; 4397 } 4398 4399 base_variable_string += var_iterator->second.initializer_with_ones; 4400 4401 for (size_t sub_script_index = 0; sub_script_index < API::MAX_ARRAY_DIMENSIONS; sub_script_index++) 4402 { 4403 base_variable_string += ")"; 4404 } 4405 4406 base_variable_string += ";\n"; 4407 } /* for (int variable_declaration_index = 0; ...) */ 4408 4409 /* Run positive case */ 4410 { 4411 std::string shader_source; 4412 4413 shader_source = base_variable_string + "\n"; 4414 shader_source += shader_start + valid_relation_opeartors; 4415 4416 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 4417 4418 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 4419 } 4420 4421 /* Run negative cases */ 4422 for (size_t string_index = 0; 4423 string_index < sizeof(variable_relation_opeartors) / sizeof(variable_relation_opeartors[0]); 4424 string_index++) 4425 { 4426 std::string shader_source; 4427 4428 shader_source = base_variable_string + "\n"; 4429 shader_source += shader_start + variable_relation_opeartors[string_index]; 4430 4431 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 4432 4433 this->execute_negative_test(tested_shader_type, shader_source); 4434 } /* for (int string_index = 0; ...) */ 4435 } /* if var_type iterator found */ 4436 else 4437 { 4438 TCU_FAIL("Type not found."); 4439 } 4440 } /* for (int var_type_index = 0; ...) */ 4441 } 4442 4443 /* Generates the shader source code for the InteractionFunctionCalls1 4444 * array tests, and attempts to compile each test shader, for both 4445 * vertex and fragment shaders. 4446 * 4447 * @tparam API Tested API descriptor 4448 * 4449 * @param tested_shader_type The type of shader that is being tested 4450 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 4451 */ 4452 template <class API> 4453 void InteractionFunctionCalls1<API>::test_shader_compilation( 4454 typename TestCaseBase<API>::TestShaderType tested_shader_type) 4455 { 4456 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 4457 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 4458 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 4459 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 4460 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 4461 4462 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 4463 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 4464 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 4465 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 4466 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 4467 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 4468 4469 const std::string iteration_loop_end = " }\n" 4470 " }\n" 4471 " }\n" 4472 " }\n" 4473 " }\n" 4474 " }\n" 4475 " }\n" 4476 " }\n"; 4477 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 4478 " {\n" 4479 " for (uint b = 0u; b < 2u; b++)\n" 4480 " {\n" 4481 " for (uint c = 0u; c < 2u; c++)\n" 4482 " {\n" 4483 " for (uint d = 0u; d < 2u; d++)\n" 4484 " {\n" 4485 " for (uint e = 0u; e < 2u; e++)\n" 4486 " {\n" 4487 " for (uint f = 0u; f < 2u; f++)\n" 4488 " {\n" 4489 " for (uint g = 0u; g < 2u; g++)\n" 4490 " {\n" 4491 " for (uint h = 0u; h < 2u; h++)\n" 4492 " {\n"; 4493 const glcts::test_var_type* var_types_set = var_types_set_es; 4494 size_t num_var_types = num_var_types_es; 4495 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 4496 4497 if (API::USE_DOUBLE) 4498 { 4499 var_types_set = var_types_set_gl; 4500 num_var_types = num_var_types_gl; 4501 } 4502 4503 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 4504 { 4505 _supported_variable_types_map_const_iterator var_iterator = 4506 supported_variable_types_map.find(var_types_set[var_type_index]); 4507 4508 if (var_iterator != supported_variable_types_map.end()) 4509 { 4510 std::string iterator_declaration = " " + var_iterator->second.iterator_type + 4511 " iterator = " + var_iterator->second.iterator_initialization + ";\n"; 4512 4513 std::string function_definition; 4514 std::string function_use; 4515 std::string verification; 4516 4517 function_definition = "void my_function(out "; 4518 function_definition += var_iterator->second.type; 4519 function_definition += " output_array[2][2][2][2][2][2][2][2]) {\n"; 4520 function_definition += iterator_declaration; 4521 function_definition += iteration_loop_start; 4522 function_definition += " output_array[a][b][c][d][e][f][g][h] = " + 4523 var_iterator->second.variable_type_initializer1 + ";\n"; 4524 function_definition += 4525 " iterator += " + var_iterator->second.iterator_type + "(1);\n"; 4526 function_definition += iteration_loop_end; 4527 function_definition += "}"; 4528 4529 function_use = " " + var_iterator->second.type + " my_array[2][2][2][2][2][2][2][2];\n"; 4530 function_use += " my_function(my_array);"; 4531 4532 verification = iterator_declaration; 4533 verification += " float result = 1.0;\n"; 4534 verification += iteration_loop_start; 4535 verification += " if (my_array[a][b][c][d][e][f][g][h] " + 4536 var_iterator->second.specific_element + 4537 " != iterator)\n" 4538 " {\n" 4539 " result = 0.0;\n" 4540 " }\n" 4541 " iterator += " + 4542 var_iterator->second.iterator_type + "(1);\n"; 4543 verification += iteration_loop_end; 4544 4545 if (false == test_compute) 4546 { 4547 execute_draw_test(tested_shader_type, function_definition, function_use, verification); 4548 } 4549 else 4550 { 4551 execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 4552 } 4553 4554 /* Deallocate any resources used. */ 4555 this->delete_objects(); 4556 } /* if var_type iterator found */ 4557 else 4558 { 4559 TCU_FAIL("Type not found."); 4560 } 4561 } /* for (int var_type_index = 0; ...) */ 4562 } 4563 4564 /** Executes test for compute program 4565 * 4566 * @tparam API Tested API descriptor 4567 * 4568 * @param tested_shader_type The type of shader that is being tested 4569 * @param function_definition Definition used to prepare shader 4570 * @param function_use Snippet that makes use of defined function 4571 * @param verification Snippet that verifies results 4572 **/ 4573 template <class API> 4574 void InteractionFunctionCalls1<API>::execute_dispatch_test( 4575 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 4576 const std::string& function_use, const std::string& verification) 4577 { 4578 const std::string& compute_shader_source = 4579 prepare_compute_shader(tested_shader_type, function_definition, function_use, verification); 4580 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 4581 4582 this->execute_positive_test(empty_string, empty_string, empty_string, empty_string, empty_string, 4583 compute_shader_source, false, false); 4584 4585 /* We are now ready to verify whether the returned size is correct. */ 4586 unsigned char buffer[4] = { 0 }; 4587 glw::GLuint framebuffer_object_id = 0; 4588 glw::GLint location = -1; 4589 glw::GLuint texture_object_id = 0; 4590 glw::GLuint vao_id = 0; 4591 4592 gl.useProgram(this->program_object_id); 4593 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 4594 4595 gl.genTextures(1, &texture_object_id); 4596 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed."); 4597 4598 gl.bindTexture(GL_TEXTURE_2D, texture_object_id); 4599 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed."); 4600 4601 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1); 4602 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed."); 4603 4604 gl.bindImageTexture(0 /* image unit */, texture_object_id, 0 /* level */, GL_FALSE /* layered */, 0 /* layer */, 4605 GL_WRITE_ONLY, GL_RGBA8); 4606 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() failed."); 4607 4608 location = gl.getUniformLocation(this->program_object_id, "uni_image"); 4609 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed."); 4610 4611 if (-1 == location) 4612 { 4613 TCU_FAIL("Uniform is inactive"); 4614 } 4615 4616 gl.uniform1i(location, 0 /* image unit */); 4617 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed."); 4618 4619 gl.genVertexArrays(1, &vao_id); 4620 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 4621 4622 gl.bindVertexArray(vao_id); 4623 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 4624 4625 gl.dispatchCompute(1, 1, 1); 4626 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 4627 4628 gl.genFramebuffers(1, &framebuffer_object_id); 4629 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed."); 4630 4631 gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id); 4632 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed."); 4633 4634 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0); 4635 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed."); 4636 4637 gl.viewport(0, 0, 1, 1); 4638 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed."); 4639 4640 gl.readBuffer(GL_COLOR_ATTACHMENT0); 4641 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed."); 4642 4643 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); 4644 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed."); 4645 4646 if (buffer[0] != 255) 4647 { 4648 TCU_FAIL("Invalid array size was returned."); 4649 } 4650 4651 /* Delete generated objects. */ 4652 gl.deleteTextures(1, &texture_object_id); 4653 gl.deleteFramebuffers(1, &framebuffer_object_id); 4654 gl.deleteVertexArrays(1, &vao_id); 4655 GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects."); 4656 } 4657 4658 /** Executes test for draw program 4659 * 4660 * @tparam API Tested API descriptor 4661 * 4662 * @param tested_shader_type The type of shader that is being tested 4663 * @param function_definition Definition used to prepare shader 4664 * @param function_use Snippet that makes use of defined function 4665 * @param verification Snippet that verifies results 4666 **/ 4667 template <class API> 4668 void InteractionFunctionCalls1<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type, 4669 const std::string& function_definition, 4670 const std::string& function_use, const std::string& verification) 4671 { 4672 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 4673 4674 if (API::USE_ALL_SHADER_STAGES) 4675 { 4676 const std::string& compute_shader_source = empty_string; 4677 const std::string& fragment_shader_source = 4678 this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification); 4679 const std::string& geometry_shader_source = 4680 this->prepare_geometry_shader(tested_shader_type, function_definition, function_use, verification); 4681 const std::string& tess_ctrl_shader_source = 4682 this->prepare_tess_ctrl_shader(tested_shader_type, function_definition, function_use, verification); 4683 const std::string& tess_eval_shader_source = 4684 this->prepare_tess_eval_shader(tested_shader_type, function_definition, function_use, verification); 4685 const std::string& vertex_shader_source = 4686 this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification); 4687 4688 switch (tested_shader_type) 4689 { 4690 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 4691 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 4692 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 4693 break; 4694 4695 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 4696 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4697 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 4698 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4699 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 4700 geometry_shader_source, fragment_shader_source, compute_shader_source, false, 4701 false); 4702 break; 4703 4704 default: 4705 TCU_FAIL("Invalid enum"); 4706 break; 4707 } 4708 } 4709 else 4710 { 4711 const std::string& fragment_shader_source = 4712 this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification); 4713 const std::string& vertex_shader_source = 4714 this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification); 4715 4716 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 4717 } 4718 4719 /* We are now ready to verify whether the returned size is correct. */ 4720 unsigned char buffer[4] = { 0 }; 4721 glw::GLuint framebuffer_object_id = 0; 4722 glw::GLuint texture_object_id = 0; 4723 glw::GLuint vao_id = 0; 4724 4725 gl.useProgram(this->program_object_id); 4726 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 4727 4728 gl.genTextures(1, &texture_object_id); 4729 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed."); 4730 4731 gl.bindTexture(GL_TEXTURE_2D, texture_object_id); 4732 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed."); 4733 4734 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1); 4735 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed."); 4736 4737 gl.genFramebuffers(1, &framebuffer_object_id); 4738 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed."); 4739 4740 gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id); 4741 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed."); 4742 4743 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0); 4744 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed."); 4745 4746 gl.viewport(0, 0, 1, 1); 4747 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed."); 4748 4749 gl.genVertexArrays(1, &vao_id); 4750 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 4751 4752 gl.bindVertexArray(vao_id); 4753 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 4754 4755 switch (tested_shader_type) 4756 { 4757 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */ 4758 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 4759 gl.drawArrays(GL_TRIANGLE_FAN, 0, 4); 4760 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 4761 break; 4762 4763 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 4764 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4765 /* Tesselation patch set up */ 4766 gl.patchParameteri(GL_PATCH_VERTICES, 1); 4767 GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); 4768 4769 gl.drawArrays(GL_PATCHES, 0, 1); 4770 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 4771 break; 4772 4773 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4774 gl.drawArrays(GL_POINTS, 0, 1); 4775 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 4776 break; 4777 4778 default: 4779 TCU_FAIL("Invalid enum"); 4780 break; 4781 } 4782 4783 gl.readBuffer(GL_COLOR_ATTACHMENT0); 4784 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed."); 4785 4786 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); 4787 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed."); 4788 4789 if (buffer[0] != 255) 4790 { 4791 TCU_FAIL("Invalid array size was returned."); 4792 } 4793 4794 /* Delete generated objects. */ 4795 gl.bindTexture(GL_TEXTURE_2D, 0); 4796 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 4797 gl.bindVertexArray(0); 4798 gl.deleteTextures(1, &texture_object_id); 4799 gl.deleteFramebuffers(1, &framebuffer_object_id); 4800 gl.deleteVertexArrays(1, &vao_id); 4801 GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects."); 4802 } 4803 4804 /** Prepare shader 4805 * 4806 * @tparam API Tested API descriptor 4807 * 4808 * @param tested_shader_type The type of shader that is being tested 4809 * @param function_definition Definition used to prepare shader 4810 * @param function_use Snippet that makes use of defined function 4811 * @param verification Snippet that verifies results 4812 **/ 4813 template <class API> 4814 std::string InteractionFunctionCalls1<API>::prepare_compute_shader( 4815 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 4816 const std::string& function_use, const std::string& verification) 4817 { 4818 std::string compute_shader_source; 4819 4820 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type) 4821 { 4822 compute_shader_source = "writeonly uniform image2D uni_image;\n" 4823 "\n"; 4824 4825 /* User-defined function definition. */ 4826 compute_shader_source += function_definition; 4827 compute_shader_source += "\n\n"; 4828 4829 /* Main function definition. */ 4830 compute_shader_source += shader_start; 4831 compute_shader_source += function_use; 4832 compute_shader_source += "\n\n"; 4833 compute_shader_source += verification; 4834 compute_shader_source += "\n\n"; 4835 compute_shader_source += "\n" 4836 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n" 4837 "}\n" 4838 "\n"; 4839 } 4840 4841 return compute_shader_source; 4842 } 4843 4844 /** Prepare shader 4845 * 4846 * @tparam API Tested API descriptor 4847 * 4848 * @param tested_shader_type The type of shader that is being tested 4849 * @param function_definition Definition used to prepare shader 4850 * @param function_use Snippet that makes use of defined function 4851 * @param verification Snippet that verifies results 4852 **/ 4853 template <class API> 4854 std::string InteractionFunctionCalls1<API>::prepare_fragment_shader( 4855 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 4856 const std::string& function_use, const std::string& verification) 4857 { 4858 std::string fragment_shader_source; 4859 4860 switch (tested_shader_type) 4861 { 4862 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 4863 break; 4864 4865 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 4866 fragment_shader_source = "out vec4 colour;\n\n"; 4867 4868 /* User-defined function definition. */ 4869 fragment_shader_source += function_definition; 4870 fragment_shader_source += "\n\n"; 4871 4872 /* Main function definition. */ 4873 fragment_shader_source += shader_start; 4874 fragment_shader_source += function_use; 4875 fragment_shader_source += "\n\n"; 4876 fragment_shader_source += verification; 4877 fragment_shader_source += "\n\n"; 4878 fragment_shader_source += " colour = vec4(result);\n"; 4879 fragment_shader_source += shader_end; 4880 break; 4881 4882 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4883 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 4884 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4885 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 4886 fragment_shader_source = "in float fs_result;\n\n" 4887 "out vec4 colour;\n\n" 4888 "void main()\n" 4889 "{\n" 4890 " colour = vec4(fs_result);\n" 4891 "}\n" 4892 "\n"; 4893 break; 4894 4895 default: 4896 TCU_FAIL("Unrecognized shader object type."); 4897 break; 4898 } 4899 4900 return fragment_shader_source; 4901 } 4902 4903 /** Prepare shader 4904 * 4905 * @tparam API Tested API descriptor 4906 * 4907 * @param tested_shader_type The type of shader that is being tested 4908 * @param function_definition Definition used to prepare shader 4909 * @param function_use Snippet that makes use of defined function 4910 * @param verification Snippet that verifies results 4911 **/ 4912 template <class API> 4913 std::string InteractionFunctionCalls1<API>::prepare_geometry_shader( 4914 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 4915 const std::string& function_use, const std::string& verification) 4916 { 4917 std::string geometry_shader_source; 4918 4919 switch (tested_shader_type) 4920 { 4921 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 4922 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 4923 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 4924 break; 4925 4926 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 4927 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 4928 geometry_shader_source = "layout(points) in;\n" 4929 "layout(triangle_strip, max_vertices = 4) out;\n" 4930 "\n" 4931 "in float tes_result[];\n" 4932 "out float fs_result;\n" 4933 "\n" 4934 "void main()\n" 4935 "{\n" 4936 " gl_Position = vec4(-1, -1, 0, 1);\n" 4937 " fs_result = tes_result[0];\n" 4938 " EmitVertex();\n" 4939 " gl_Position = vec4(-1, 1, 0, 1);\n" 4940 " fs_result = tes_result[0];\n" 4941 " EmitVertex();\n" 4942 " gl_Position = vec4(1, -1, 0, 1);\n" 4943 " fs_result = tes_result[0];\n" 4944 " EmitVertex();\n" 4945 " gl_Position = vec4(1, 1, 0, 1);\n" 4946 " fs_result = tes_result[0];\n" 4947 " EmitVertex();\n" 4948 "}\n"; 4949 break; 4950 4951 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 4952 geometry_shader_source = "layout(points) in;\n" 4953 "layout(triangle_strip, max_vertices = 4) out;\n" 4954 "\n" 4955 "out float fs_result;\n" 4956 "\n"; 4957 4958 /* User-defined function definition. */ 4959 geometry_shader_source += function_definition; 4960 geometry_shader_source += "\n\n"; 4961 4962 /* Main function definition. */ 4963 geometry_shader_source += shader_start; 4964 geometry_shader_source += function_use; 4965 geometry_shader_source += "\n\n"; 4966 geometry_shader_source += verification; 4967 geometry_shader_source += "\n\n"; 4968 geometry_shader_source += "\n gl_Position = vec4(-1, -1, 0, 1);\n" 4969 " fs_result = result;\n" 4970 " EmitVertex();\n" 4971 " gl_Position = vec4(-1, 1, 0, 1);\n" 4972 " fs_result = result;\n" 4973 " EmitVertex();\n" 4974 " gl_Position = vec4(1, -1, 0, 1);\n" 4975 " fs_result = result;\n" 4976 " EmitVertex();\n" 4977 " gl_Position = vec4(1, 1, 0, 1);\n" 4978 " fs_result = result;\n" 4979 " EmitVertex();\n" 4980 "}\n"; 4981 break; 4982 4983 default: 4984 TCU_FAIL("Unrecognized shader object type."); 4985 break; 4986 } 4987 4988 return geometry_shader_source; 4989 } 4990 4991 /** Prepare shader 4992 * 4993 * @tparam API Tested API descriptor 4994 * 4995 * @param tested_shader_type The type of shader that is being tested 4996 * @param function_definition Definition used to prepare shader 4997 * @param function_use Snippet that makes use of defined function 4998 * @param verification Snippet that verifies results 4999 **/ 5000 template <class API> 5001 std::string InteractionFunctionCalls1<API>::prepare_tess_ctrl_shader( 5002 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 5003 const std::string& function_use, const std::string& verification) 5004 { 5005 std::string tess_ctrl_shader_source; 5006 5007 switch (tested_shader_type) 5008 { 5009 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 5010 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 5011 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 5012 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 5013 break; 5014 5015 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 5016 tess_ctrl_shader_source = "layout(vertices = 1) out;\n" 5017 "\n" 5018 "out float tcs_result[];\n" 5019 "\n"; 5020 5021 /* User-defined function definition. */ 5022 tess_ctrl_shader_source += function_definition; 5023 tess_ctrl_shader_source += "\n\n"; 5024 5025 /* Main function definition. */ 5026 tess_ctrl_shader_source += shader_start; 5027 tess_ctrl_shader_source += function_use; 5028 tess_ctrl_shader_source += "\n\n"; 5029 tess_ctrl_shader_source += verification; 5030 tess_ctrl_shader_source += "\n\n"; 5031 tess_ctrl_shader_source += " tcs_result[gl_InvocationID] = result;\n" 5032 "\n" 5033 " gl_TessLevelOuter[0] = 1.0;\n" 5034 " gl_TessLevelOuter[1] = 1.0;\n" 5035 " gl_TessLevelOuter[2] = 1.0;\n" 5036 " gl_TessLevelOuter[3] = 1.0;\n" 5037 " gl_TessLevelInner[0] = 1.0;\n" 5038 " gl_TessLevelInner[1] = 1.0;\n" 5039 "}\n"; 5040 break; 5041 5042 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 5043 tess_ctrl_shader_source = default_tc_shader_source; 5044 break; 5045 5046 default: 5047 TCU_FAIL("Unrecognized shader object type."); 5048 break; 5049 } 5050 5051 return tess_ctrl_shader_source; 5052 } 5053 5054 /** Prepare shader 5055 * 5056 * @tparam API Tested API descriptor 5057 * 5058 * @param tested_shader_type The type of shader that is being tested 5059 * @param function_definition Definition used to prepare shader 5060 * @param function_use Snippet that makes use of defined function 5061 * @param verification Snippet that verifies results 5062 **/ 5063 template <class API> 5064 std::string InteractionFunctionCalls1<API>::prepare_tess_eval_shader( 5065 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 5066 const std::string& function_use, const std::string& verification) 5067 { 5068 std::string tess_eval_shader_source; 5069 5070 switch (tested_shader_type) 5071 { 5072 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 5073 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 5074 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 5075 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 5076 break; 5077 5078 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 5079 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 5080 "\n" 5081 "in float tcs_result[];\n" 5082 "out float tes_result;\n" 5083 "\n" 5084 "void main()\n" 5085 "{\n" 5086 " tes_result = tcs_result[0];\n" 5087 "}\n"; 5088 break; 5089 5090 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 5091 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 5092 "\n" 5093 "out float tes_result;\n" 5094 "\n"; 5095 5096 /* User-defined function definition. */ 5097 tess_eval_shader_source += function_definition; 5098 tess_eval_shader_source += "\n\n"; 5099 5100 /* Main function definition. */ 5101 tess_eval_shader_source += shader_start; 5102 tess_eval_shader_source += function_use; 5103 tess_eval_shader_source += "\n\n"; 5104 tess_eval_shader_source += verification; 5105 tess_eval_shader_source += "\n\n"; 5106 tess_eval_shader_source += " tes_result = result;\n" 5107 "}\n"; 5108 break; 5109 5110 default: 5111 TCU_FAIL("Unrecognized shader object type."); 5112 break; 5113 } 5114 5115 return tess_eval_shader_source; 5116 } 5117 5118 /** Prepare shader 5119 * 5120 * @tparam API Tested API descriptor 5121 * 5122 * @param tested_shader_type The type of shader that is being tested 5123 * @param function_definition Definition used to prepare shader 5124 * @param function_use Snippet that makes use of defined function 5125 * @param verification Snippet that verifies results 5126 **/ 5127 template <class API> 5128 std::string InteractionFunctionCalls1<API>::prepare_vertex_shader( 5129 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 5130 const std::string& function_use, const std::string& verification) 5131 { 5132 std::string vertex_shader_source; 5133 5134 switch (tested_shader_type) 5135 { 5136 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 5137 break; 5138 5139 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 5140 vertex_shader_source = "/** GL_TRIANGLE_FAN-type quad vertex data. */\n" 5141 "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n" 5142 " vec4(-1.0, -1.0, 0.0, 1.0),\n" 5143 " vec4(-1.0, 1.0, 0.0, 1.0),\n" 5144 " vec4( 1.0, 1.0, 0.0, 1.0) );\n" 5145 "\n" 5146 "void main()\n" 5147 "{\n" 5148 " gl_Position = vertex_positions[gl_VertexID];" 5149 "}\n\n"; 5150 break; 5151 5152 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 5153 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 5154 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 5155 vertex_shader_source = default_vertex_shader_source; 5156 break; 5157 5158 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 5159 /* Vertex shader source. */ 5160 vertex_shader_source = "out float fs_result;\n\n"; 5161 vertex_shader_source += "/** GL_TRIANGLE_FAN-type quad vertex data. */\n" 5162 "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n" 5163 " vec4(-1.0, -1.0, 0.0, 1.0),\n" 5164 " vec4(-1.0, 1.0, 0.0, 1.0),\n" 5165 " vec4( 1.0, 1.0, 0.0, 1.0) );\n\n"; 5166 5167 /* User-defined function definition. */ 5168 vertex_shader_source += function_definition; 5169 vertex_shader_source += "\n\n"; 5170 5171 /* Main function definition. */ 5172 vertex_shader_source += shader_start; 5173 vertex_shader_source += function_use; 5174 vertex_shader_source += "\n\n"; 5175 vertex_shader_source += verification; 5176 vertex_shader_source += "\n\n"; 5177 vertex_shader_source += " fs_result = result;\n" 5178 " gl_Position = vertex_positions[gl_VertexID];\n"; 5179 vertex_shader_source += shader_end; 5180 break; 5181 5182 default: 5183 TCU_FAIL("Unrecognized shader object type."); 5184 break; 5185 } 5186 5187 return vertex_shader_source; 5188 } 5189 5190 /* Generates the shader source code for the InteractionFunctionCalls2 5191 * array tests, and attempts to compile each test shader, for both 5192 * vertex and fragment shaders. 5193 * 5194 * @tparam API Tested API descriptor 5195 * 5196 * @param tested_shader_type The type of shader that is being tested 5197 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 5198 */ 5199 template <class API> 5200 void InteractionFunctionCalls2<API>::test_shader_compilation( 5201 typename TestCaseBase<API>::TestShaderType tested_shader_type) 5202 { 5203 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 5204 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 5205 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 5206 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 5207 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 5208 5209 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 5210 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 5211 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 5212 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 5213 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 5214 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 5215 5216 const std::string iteration_loop_end = " }\n" 5217 " }\n" 5218 " }\n" 5219 " }\n" 5220 " }\n" 5221 " }\n" 5222 " }\n" 5223 " }\n"; 5224 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 5225 " {\n" 5226 " for (uint b = 0u; b < 2u; b++)\n" 5227 " {\n" 5228 " for (uint c = 0u; c < 2u; c++)\n" 5229 " {\n" 5230 " for (uint d = 0u; d < 2u; d++)\n" 5231 " {\n" 5232 " for (uint e = 0u; e < 2u; e++)\n" 5233 " {\n" 5234 " for (uint f = 0u; f < 2u; f++)\n" 5235 " {\n" 5236 " for (uint g = 0u; g < 2u; g++)\n" 5237 " {\n" 5238 " for (uint h = 0u; h < 2u; h++)\n" 5239 " {\n"; 5240 const std::string multiplier_array = "const int[] multiplier_array = int[]( 1, 2, 3, 4, 5, 6, 7, 8,\n" 5241 " 11, 12, 13, 14, 15, 16, 17, 18,\n" 5242 " 21, 22, 23, 24, 25, 26, 27, 28,\n" 5243 " 31, 32, 33, 34, 35, 36, 37, 38,\n" 5244 " 41, 42, 43, 44, 45, 46, 47, 48,\n" 5245 " 51, 52, 53, 54, 55, 56, 57, 58,\n" 5246 " 61, 62, 63, 64, 65, 66, 67, 68,\n" 5247 " 71, 72, 73, 74, 75, 76, 77, 78,\n" 5248 " 81, 82, 83, 84, 85, 86, 87, 88);\n"; 5249 const glcts::test_var_type* var_types_set = var_types_set_es; 5250 size_t num_var_types = num_var_types_es; 5251 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 5252 5253 if (API::USE_DOUBLE) 5254 { 5255 var_types_set = var_types_set_gl; 5256 num_var_types = num_var_types_gl; 5257 } 5258 5259 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 5260 { 5261 _supported_variable_types_map_const_iterator var_iterator = 5262 supported_variable_types_map.find(var_types_set[var_type_index]); 5263 5264 if (var_iterator != supported_variable_types_map.end()) 5265 { 5266 std::string function_definition; 5267 std::string function_use; 5268 std::string verification; 5269 5270 function_definition += multiplier_array; 5271 function_definition += "void my_function(inout "; 5272 function_definition += var_iterator->second.type; 5273 function_definition += " inout_array[2][2][2][2][2][2][2][2]) {\n" 5274 " uint i = 0u;\n"; 5275 function_definition += iteration_loop_start; 5276 function_definition += " inout_array[a][b][c][d][e][f][g][h] *= " + 5277 var_iterator->second.iterator_type + "(multiplier_array[i % 64u]);\n"; 5278 function_definition += " i+= 1u;\n"; 5279 function_definition += iteration_loop_end; 5280 function_definition += "}"; 5281 5282 function_use += " float result = 1.0;\n"; 5283 function_use += " uint iterator = 0u;\n"; 5284 function_use += " " + var_iterator->second.type + " my_array[2][2][2][2][2][2][2][2];\n"; 5285 function_use += iteration_loop_start; 5286 function_use += " my_array[a][b][c][d][e][f][g][h] = " + 5287 var_iterator->second.variable_type_initializer2 + ";\n"; 5288 function_use += iteration_loop_end; 5289 function_use += " my_function(my_array);"; 5290 5291 verification += iteration_loop_start; 5292 verification += " if (my_array[a][b][c][d][e][f][g][h] " + 5293 var_iterator->second.specific_element + "!= " + var_iterator->second.iterator_type + 5294 "(multiplier_array[iterator % 64u]))\n" 5295 " {\n" 5296 " result = 0.0;\n" 5297 " }\n" 5298 " iterator += 1u;\n"; 5299 verification += iteration_loop_end; 5300 5301 if (false == test_compute) 5302 { 5303 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification); 5304 } 5305 else 5306 { 5307 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 5308 } 5309 5310 /* Deallocate any resources used. */ 5311 this->delete_objects(); 5312 } /* if var_type iterator found */ 5313 else 5314 { 5315 TCU_FAIL("Type not found."); 5316 } 5317 } /* for (int var_type_index = 0; ...) */ 5318 } 5319 5320 /* Generates the shader source code for the InteractionArgumentAliasing1 5321 * array tests, and attempts to compile each test shader, for both 5322 * vertex and fragment shaders. 5323 * 5324 * @tparam API Tested API descriptor 5325 * 5326 * @param tested_shader_type The type of shader that is being tested 5327 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 5328 */ 5329 template <class API> 5330 void InteractionArgumentAliasing1<API>::test_shader_compilation( 5331 typename TestCaseBase<API>::TestShaderType tested_shader_type) 5332 { 5333 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4 }; 5334 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 5335 5336 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4, 5337 VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4 }; 5338 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 5339 5340 const std::string iteration_loop_end = " }\n" 5341 " }\n" 5342 " }\n" 5343 " }\n" 5344 " }\n" 5345 " }\n" 5346 " }\n" 5347 " }\n"; 5348 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 5349 " {\n" 5350 " for (uint b = 0u; b < 2u; b++)\n" 5351 " {\n" 5352 " for (uint c = 0u; c < 2u; c++)\n" 5353 " {\n" 5354 " for (uint d = 0u; d < 2u; d++)\n" 5355 " {\n" 5356 " for (uint e = 0u; e < 2u; e++)\n" 5357 " {\n" 5358 " for (uint f = 0u; f < 2u; f++)\n" 5359 " {\n" 5360 " for (uint g = 0u; g < 2u; g++)\n" 5361 " {\n" 5362 " for (uint h = 0u; h < 2u; h++)\n" 5363 " {\n"; 5364 const glcts::test_var_type* var_types_set = var_types_set_es; 5365 size_t num_var_types = num_var_types_es; 5366 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 5367 5368 if (API::USE_DOUBLE) 5369 { 5370 var_types_set = var_types_set_gl; 5371 num_var_types = num_var_types_gl; 5372 } 5373 5374 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 5375 { 5376 _supported_variable_types_map_const_iterator var_iterator = 5377 supported_variable_types_map.find(var_types_set[var_type_index]); 5378 5379 if (var_iterator != supported_variable_types_map.end()) 5380 { 5381 std::string array_declaration = var_iterator->second.type + " z[2][2][2][2][2][2][2][2];\n\n"; 5382 5383 std::string function_definition; 5384 std::string function_use; 5385 std::string verification; 5386 5387 function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2][2][2][2][2], "; 5388 function_definition += var_iterator->second.type + " y[2][2][2][2][2][2][2][2])\n"; 5389 function_definition += "{\n"; 5390 function_definition += " " + iteration_loop_start; 5391 function_definition += 5392 " x[a][b][c][d][e][f][g][h] = " + var_iterator->second.type + "(123);\n"; 5393 function_definition += " " + iteration_loop_end; 5394 function_definition += "\n"; 5395 function_definition += " " + iteration_loop_start; 5396 function_definition += " if(y[a][b][c][d][e][f][g][h]"; 5397 if (var_iterator->second.type == "mat4") // mat4 comparison 5398 { 5399 function_definition += "[0][0]"; 5400 function_definition += " != float"; 5401 } 5402 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 5403 { 5404 function_definition += "[0][0]"; 5405 function_definition += " != double"; 5406 } 5407 else 5408 { 5409 function_definition += " != "; 5410 function_definition += var_iterator->second.type; 5411 } 5412 function_definition += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h))) {return false;}\n"; 5413 function_definition += " " + iteration_loop_end; 5414 function_definition += " return true;\n"; 5415 function_definition += "}"; 5416 5417 function_use += " " + array_declaration; 5418 function_use += " " + iteration_loop_start; 5419 function_use += " z[a][b][c][d][e][f][g][h] = "; 5420 function_use += var_iterator->second.type; 5421 function_use += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h));\n"; 5422 function_use += " " + iteration_loop_end; 5423 5424 verification += " float result = 0.0;\n"; 5425 verification += " if(gfunc(z, z) == true)\n"; 5426 verification += " {\n"; 5427 verification += " result = 1.0;\n\n"; 5428 verification += " }\n"; 5429 verification += " else\n"; 5430 verification += " {\n"; 5431 verification += " result = 0.0;\n\n"; 5432 verification += " }\n"; 5433 5434 if (false == test_compute) 5435 { 5436 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification); 5437 } 5438 else 5439 { 5440 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 5441 } 5442 5443 /* Deallocate any resources used. */ 5444 this->delete_objects(); 5445 } /* if var_type iterator found */ 5446 else 5447 { 5448 TCU_FAIL("Type not found."); 5449 } 5450 } 5451 } 5452 5453 /* Generates the shader source code for the InteractionArgumentAliasing2 5454 * array tests, and attempts to compile each test shader, for both 5455 * vertex and fragment shaders. 5456 * 5457 * @tparam API Tested API descriptor 5458 * 5459 * @param tested_shader_type The type of shader that is being tested 5460 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 5461 */ 5462 template <class API> 5463 void InteractionArgumentAliasing2<API>::test_shader_compilation( 5464 typename TestCaseBase<API>::TestShaderType tested_shader_type) 5465 { 5466 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4 }; 5467 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 5468 5469 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4, 5470 VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4 }; 5471 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 5472 5473 const std::string iteration_loop_end = " }\n" 5474 " }\n" 5475 " }\n" 5476 " }\n" 5477 " }\n" 5478 " }\n" 5479 " }\n" 5480 " }\n"; 5481 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 5482 " {\n" 5483 " for (uint b = 0u; b < 2u; b++)\n" 5484 " {\n" 5485 " for (uint c = 0u; c < 2u; c++)\n" 5486 " {\n" 5487 " for (uint d = 0u; d < 2u; d++)\n" 5488 " {\n" 5489 " for (uint e = 0u; e < 2u; e++)\n" 5490 " {\n" 5491 " for (uint f = 0u; f < 2u; f++)\n" 5492 " {\n" 5493 " for (uint g = 0u; g < 2u; g++)\n" 5494 " {\n" 5495 " for (uint h = 0u; h < 2u; h++)\n" 5496 " {\n"; 5497 const glcts::test_var_type* var_types_set = var_types_set_es; 5498 size_t num_var_types = num_var_types_es; 5499 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 5500 5501 if (API::USE_DOUBLE) 5502 { 5503 var_types_set = var_types_set_gl; 5504 num_var_types = num_var_types_gl; 5505 } 5506 5507 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 5508 { 5509 _supported_variable_types_map_const_iterator var_iterator = 5510 supported_variable_types_map.find(var_types_set[var_type_index]); 5511 5512 if (var_iterator != supported_variable_types_map.end()) 5513 { 5514 std::string array_declaration = var_iterator->second.type + " z[2][2][2][2][2][2][2][2];\n\n"; 5515 5516 std::string function_definition; 5517 std::string function_use; 5518 std::string verification; 5519 5520 function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2][2][2][2][2], "; 5521 function_definition += var_iterator->second.type + " y[2][2][2][2][2][2][2][2])\n"; 5522 function_definition += "{\n"; 5523 function_definition += " " + iteration_loop_start; 5524 function_definition += 5525 " y[a][b][c][d][e][f][g][h] = " + var_iterator->second.type + 5526 "(123);\n"; 5527 function_definition += " " + iteration_loop_end; 5528 function_definition += "\n"; 5529 function_definition += " " + iteration_loop_start; 5530 function_definition += " if(x[a][b][c][d][e][f][g][h]"; 5531 if (var_iterator->second.type == "mat4") // mat4 comparison 5532 { 5533 function_definition += "[0][0]"; 5534 function_definition += " != float"; 5535 } 5536 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 5537 { 5538 function_definition += "[0][0]"; 5539 function_definition += " != double"; 5540 } 5541 else 5542 { 5543 function_definition += " != "; 5544 function_definition += var_iterator->second.type; 5545 } 5546 function_definition += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h))) {return false;}\n"; 5547 function_definition += " " + iteration_loop_end; 5548 function_definition += " return true;\n"; 5549 function_definition += "}"; 5550 5551 function_use += " " + array_declaration; 5552 function_use += " " + iteration_loop_start; 5553 function_use += " z[a][b][c][d][e][f][g][h] = "; 5554 function_use += var_iterator->second.type; 5555 function_use += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h));\n"; 5556 function_use += " " + iteration_loop_end; 5557 5558 verification += " float result = 0.0;\n"; 5559 verification += " if(gfunc(z, z) == true)\n"; 5560 verification += " {\n"; 5561 verification += " result = 1.0;\n\n"; 5562 verification += " }\n"; 5563 verification += " else\n"; 5564 verification += " {\n"; 5565 verification += " result = 0.0;\n\n"; 5566 verification += " }\n"; 5567 5568 if (false == test_compute) 5569 { 5570 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification); 5571 } 5572 else 5573 { 5574 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 5575 } 5576 5577 /* Deallocate any resources used. */ 5578 this->delete_objects(); 5579 } /* if var_type iterator found */ 5580 else 5581 { 5582 TCU_FAIL("Type not found."); 5583 } 5584 } 5585 } 5586 5587 /* Generates the shader source code for the InteractionArgumentAliasing3 5588 * array tests, and attempts to compile each test shader, for both 5589 * vertex and fragment shaders. 5590 * 5591 * @tparam API Tested API descriptor 5592 * 5593 * @param tested_shader_type The type of shader that is being tested 5594 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 5595 */ 5596 template <class API> 5597 void InteractionArgumentAliasing3<API>::test_shader_compilation( 5598 typename TestCaseBase<API>::TestShaderType tested_shader_type) 5599 { 5600 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4 }; 5601 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 5602 5603 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4, 5604 VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4 }; 5605 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 5606 5607 const std::string iteration_loop_end = " }\n" 5608 " }\n" 5609 " }\n" 5610 " }\n" 5611 " }\n" 5612 " }\n" 5613 " }\n" 5614 " }\n"; 5615 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 5616 " {\n" 5617 " for (uint b = 0u; b < 2u; b++)\n" 5618 " {\n" 5619 " for (uint c = 0u; c < 2u; c++)\n" 5620 " {\n" 5621 " for (uint d = 0u; d < 2u; d++)\n" 5622 " {\n" 5623 " for (uint e = 0u; e < 2u; e++)\n" 5624 " {\n" 5625 " for (uint f = 0u; f < 2u; f++)\n" 5626 " {\n" 5627 " for (uint g = 0u; g < 2u; g++)\n" 5628 " {\n" 5629 " for (uint h = 0u; h < 2u; h++)\n" 5630 " {\n"; 5631 const glcts::test_var_type* var_types_set = var_types_set_es; 5632 size_t num_var_types = num_var_types_es; 5633 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 5634 5635 if (API::USE_DOUBLE) 5636 { 5637 var_types_set = var_types_set_gl; 5638 num_var_types = num_var_types_gl; 5639 } 5640 5641 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 5642 { 5643 _supported_variable_types_map_const_iterator var_iterator = 5644 supported_variable_types_map.find(var_types_set[var_type_index]); 5645 5646 if (var_iterator != supported_variable_types_map.end()) 5647 { 5648 std::string array_declaration = var_iterator->second.type + " z[2][2][2][2][2][2][2][2];\n\n"; 5649 5650 std::string function_definition; 5651 std::string function_use; 5652 std::string verification; 5653 5654 function_definition += "bool gfunc(out " + var_iterator->second.type + " x[2][2][2][2][2][2][2][2], "; 5655 function_definition += var_iterator->second.type + " y[2][2][2][2][2][2][2][2])\n"; 5656 function_definition += "{\n"; 5657 function_definition += " " + iteration_loop_start; 5658 function_definition += 5659 " x[a][b][c][d][e][f][g][h] = " + var_iterator->second.type + 5660 "(123);\n"; 5661 function_definition += " " + iteration_loop_end; 5662 function_definition += "\n"; 5663 function_definition += " " + iteration_loop_start; 5664 function_definition += " if(y[a][b][c][d][e][f][g][h]"; 5665 if (var_iterator->second.type == "mat4") // mat4 comparison 5666 { 5667 function_definition += "[0][0]"; 5668 function_definition += " != float"; 5669 } 5670 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 5671 { 5672 function_definition += "[0][0]"; 5673 function_definition += " != double"; 5674 } 5675 else 5676 { 5677 function_definition += " != "; 5678 function_definition += var_iterator->second.type; 5679 } 5680 function_definition += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h))) {return false;}\n"; 5681 function_definition += " " + iteration_loop_end; 5682 function_definition += " return true;\n"; 5683 function_definition += "}\n\n"; 5684 5685 function_use += " " + array_declaration; 5686 function_use += " " + iteration_loop_start; 5687 function_use += " z[a][b][c][d][e][f][g][h] = "; 5688 function_use += var_iterator->second.type; 5689 function_use += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h));\n"; 5690 function_use += " " + iteration_loop_end; 5691 5692 verification += " float result = 0.0;\n"; 5693 verification += " if(gfunc(z, z) == true)\n"; 5694 verification += " {\n"; 5695 verification += " result = 1.0;\n\n"; 5696 verification += " }\n"; 5697 verification += " else\n"; 5698 verification += " {\n"; 5699 verification += " result = 0.0;\n\n"; 5700 verification += " }\n"; 5701 5702 if (false == test_compute) 5703 { 5704 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification); 5705 } 5706 else 5707 { 5708 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 5709 } 5710 5711 /* Deallocate any resources used. */ 5712 this->delete_objects(); 5713 } /* if var_type iterator found */ 5714 else 5715 { 5716 TCU_FAIL("Type not found."); 5717 } 5718 } 5719 } 5720 5721 /* Generates the shader source code for the InteractionArgumentAliasing4 5722 * array tests, and attempts to compile each test shader, for both 5723 * vertex and fragment shaders. 5724 * 5725 * @tparam API Tested API descriptor 5726 * 5727 * @param tested_shader_type The type of shader that is being tested 5728 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 5729 */ 5730 template <class API> 5731 void InteractionArgumentAliasing4<API>::test_shader_compilation( 5732 typename TestCaseBase<API>::TestShaderType tested_shader_type) 5733 { 5734 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4 }; 5735 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 5736 5737 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4, 5738 VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4 }; 5739 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 5740 5741 const std::string iteration_loop_end = " }\n" 5742 " }\n" 5743 " }\n" 5744 " }\n" 5745 " }\n" 5746 " }\n" 5747 " }\n" 5748 " }\n"; 5749 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 5750 " {\n" 5751 " for (uint b = 0u; b < 2u; b++)\n" 5752 " {\n" 5753 " for (uint c = 0u; c < 2u; c++)\n" 5754 " {\n" 5755 " for (uint d = 0u; d < 2u; d++)\n" 5756 " {\n" 5757 " for (uint e = 0u; e < 2u; e++)\n" 5758 " {\n" 5759 " for (uint f = 0u; f < 2u; f++)\n" 5760 " {\n" 5761 " for (uint g = 0u; g < 2u; g++)\n" 5762 " {\n" 5763 " for (uint h = 0u; h < 2u; h++)\n" 5764 " {\n"; 5765 const glcts::test_var_type* var_types_set = var_types_set_es; 5766 size_t num_var_types = num_var_types_es; 5767 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 5768 5769 if (API::USE_DOUBLE) 5770 { 5771 var_types_set = var_types_set_gl; 5772 num_var_types = num_var_types_gl; 5773 } 5774 5775 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 5776 { 5777 _supported_variable_types_map_const_iterator var_iterator = 5778 supported_variable_types_map.find(var_types_set[var_type_index]); 5779 5780 if (var_iterator != supported_variable_types_map.end()) 5781 { 5782 std::string array_declaration = var_iterator->second.type + "[2][2][2][2][2][2][2][2] z;\n\n"; 5783 5784 std::string function_definition; 5785 std::string function_use; 5786 std::string verification; 5787 5788 function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2][2][2][2][2], "; 5789 function_definition += "out " + var_iterator->second.type + " y[2][2][2][2][2][2][2][2])\n"; 5790 function_definition += "{\n"; 5791 function_definition += " " + iteration_loop_start; 5792 function_definition += 5793 " y[a][b][c][d][e][f][g][h] = " + var_iterator->second.type + 5794 "(123);\n"; 5795 function_definition += " " + iteration_loop_end; 5796 function_definition += "\n"; 5797 function_definition += " " + iteration_loop_start; 5798 function_definition += " if(x[a][b][c][d][e][f][g][h]"; 5799 if (var_iterator->second.type == "mat4") // mat4 comparison 5800 { 5801 function_definition += "[0][0]"; 5802 function_definition += " != float"; 5803 } 5804 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 5805 { 5806 function_definition += "[0][0]"; 5807 function_definition += " != double"; 5808 } 5809 else 5810 { 5811 function_definition += " != "; 5812 function_definition += var_iterator->second.type; 5813 } 5814 function_definition += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h))) {return false;}\n"; 5815 function_definition += " " + iteration_loop_end; 5816 function_definition += " return true;\n"; 5817 function_definition += "}\n\n"; 5818 5819 function_use += " " + array_declaration; 5820 function_use += " " + iteration_loop_start; 5821 function_use += " z[a][b][c][d][e][f][g][h] = "; 5822 function_use += var_iterator->second.type; 5823 function_use += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h));\n"; 5824 function_use += " " + iteration_loop_end; 5825 5826 verification += " float result = 0.0;\n"; 5827 verification += " if(gfunc(z, z) == true)\n"; 5828 verification += " {\n"; 5829 verification += " result = 1.0;\n\n"; 5830 verification += " }\n"; 5831 verification += " else\n"; 5832 verification += " {\n"; 5833 verification += " result = 0.0;\n\n"; 5834 verification += " }\n"; 5835 5836 if (false == test_compute) 5837 { 5838 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification); 5839 } 5840 else 5841 { 5842 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 5843 } 5844 5845 /* Deallocate any resources used. */ 5846 this->delete_objects(); 5847 } /* if var_type iterator found */ 5848 else 5849 { 5850 TCU_FAIL("Type not found."); 5851 } 5852 } 5853 } 5854 5855 /* Generates the shader source code for the InteractionArgumentAliasing3 5856 * array tests, and attempts to compile each test shader, for both 5857 * vertex and fragment shaders. 5858 * 5859 * @tparam API Tested API descriptor 5860 * 5861 * @param tested_shader_type The type of shader that is being tested 5862 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 5863 */ 5864 template <class API> 5865 void InteractionArgumentAliasing5<API>::test_shader_compilation( 5866 typename TestCaseBase<API>::TestShaderType tested_shader_type) 5867 { 5868 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4 }; 5869 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 5870 5871 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4, 5872 VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4 }; 5873 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 5874 5875 const std::string iteration_loop_end = " }\n" 5876 " }\n" 5877 " }\n" 5878 " }\n" 5879 " }\n" 5880 " }\n" 5881 " }\n" 5882 " }\n"; 5883 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 5884 " {\n" 5885 " for (uint b = 0u; b < 2u; b++)\n" 5886 " {\n" 5887 " for (uint c = 0u; c < 2u; c++)\n" 5888 " {\n" 5889 " for (uint d = 0u; d < 2u; d++)\n" 5890 " {\n" 5891 " for (uint e = 0u; e < 2u; e++)\n" 5892 " {\n" 5893 " for (uint f = 0u; f < 2u; f++)\n" 5894 " {\n" 5895 " for (uint g = 0u; g < 2u; g++)\n" 5896 " {\n" 5897 " for (uint h = 0u; h < 2u; h++)\n" 5898 " {\n"; 5899 const glcts::test_var_type* var_types_set = var_types_set_es; 5900 size_t num_var_types = num_var_types_es; 5901 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 5902 5903 if (API::USE_DOUBLE) 5904 { 5905 var_types_set = var_types_set_gl; 5906 num_var_types = num_var_types_gl; 5907 } 5908 5909 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 5910 { 5911 _supported_variable_types_map_const_iterator var_iterator = 5912 supported_variable_types_map.find(var_types_set[var_type_index]); 5913 5914 if (var_iterator != supported_variable_types_map.end()) 5915 { 5916 std::string array_declaration = var_iterator->second.type + "[2][2][2][2][2][2][2][2] z;\n\n"; 5917 5918 std::string function_definition; 5919 std::string function_use; 5920 std::string verification; 5921 5922 function_definition += "bool gfunc(inout " + var_iterator->second.type + " x[2][2][2][2][2][2][2][2], "; 5923 function_definition += var_iterator->second.type + " y[2][2][2][2][2][2][2][2])\n"; 5924 function_definition += "{\n"; 5925 function_definition += " " + iteration_loop_start; 5926 function_definition += 5927 " x[a][b][c][d][e][f][g][h] = " + var_iterator->second.type + 5928 "(123);\n"; 5929 function_definition += " " + iteration_loop_end; 5930 function_definition += "\n"; 5931 function_definition += " " + iteration_loop_start; 5932 function_definition += " if(y[a][b][c][d][e][f][g][h]"; 5933 if (var_iterator->second.type == "mat4") // mat4 comparison 5934 { 5935 function_definition += "[0][0]"; 5936 function_definition += " != float"; 5937 } 5938 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 5939 { 5940 function_definition += "[0][0]"; 5941 function_definition += " != double"; 5942 } 5943 else 5944 { 5945 function_definition += " != "; 5946 function_definition += var_iterator->second.type; 5947 } 5948 function_definition += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h))) {return false;}\n"; 5949 function_definition += " " + iteration_loop_end; 5950 function_definition += " return true;\n"; 5951 function_definition += "}\n\n"; 5952 5953 function_use += " " + array_declaration; 5954 function_use += " " + iteration_loop_start; 5955 function_use += " z[a][b][c][d][e][f][g][h] = "; 5956 function_use += var_iterator->second.type; 5957 function_use += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h));\n"; 5958 function_use += " " + iteration_loop_end; 5959 5960 verification += " float result = 0.0;\n"; 5961 verification += " if(gfunc(z, z) == true)\n"; 5962 verification += " {\n"; 5963 verification += " result = 1.0;\n\n"; 5964 verification += " }\n"; 5965 verification += " else\n"; 5966 verification += " {\n"; 5967 verification += " result = 0.0;\n\n"; 5968 verification += " }\n"; 5969 5970 if (false == test_compute) 5971 { 5972 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification); 5973 } 5974 else 5975 { 5976 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 5977 } 5978 5979 /* Deallocate any resources used. */ 5980 this->delete_objects(); 5981 } /* if var_type iterator found */ 5982 else 5983 { 5984 TCU_FAIL("Type not found."); 5985 } 5986 } 5987 } 5988 5989 /* Generates the shader source code for the InteractionArgumentAliasing4 5990 * array tests, and attempts to compile each test shader, for both 5991 * vertex and fragment shaders. 5992 * 5993 * @tparam API Tested API descriptor 5994 * 5995 * @param tested_shader_type The type of shader that is being tested 5996 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 5997 */ 5998 template <class API> 5999 void InteractionArgumentAliasing6<API>::test_shader_compilation( 6000 typename TestCaseBase<API>::TestShaderType tested_shader_type) 6001 { 6002 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4 }; 6003 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 6004 6005 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4, 6006 VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4 }; 6007 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 6008 6009 const std::string iteration_loop_end = " }\n" 6010 " }\n" 6011 " }\n" 6012 " }\n" 6013 " }\n" 6014 " }\n" 6015 " }\n" 6016 " }\n"; 6017 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 6018 " {\n" 6019 " for (uint b = 0u; b < 2u; b++)\n" 6020 " {\n" 6021 " for (uint c = 0u; c < 2u; c++)\n" 6022 " {\n" 6023 " for (uint d = 0u; d < 2u; d++)\n" 6024 " {\n" 6025 " for (uint e = 0u; e < 2u; e++)\n" 6026 " {\n" 6027 " for (uint f = 0u; f < 2u; f++)\n" 6028 " {\n" 6029 " for (uint g = 0u; g < 2u; g++)\n" 6030 " {\n" 6031 " for (uint h = 0u; h < 2u; h++)\n" 6032 " {\n"; 6033 const glcts::test_var_type* var_types_set = var_types_set_es; 6034 size_t num_var_types = num_var_types_es; 6035 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 6036 6037 if (API::USE_DOUBLE) 6038 { 6039 var_types_set = var_types_set_gl; 6040 num_var_types = num_var_types_gl; 6041 } 6042 6043 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 6044 { 6045 _supported_variable_types_map_const_iterator var_iterator = 6046 supported_variable_types_map.find(var_types_set[var_type_index]); 6047 6048 if (var_iterator != supported_variable_types_map.end()) 6049 { 6050 std::string array_declaration = var_iterator->second.type + "[2][2][2][2][2][2][2][2] z;\n\n"; 6051 6052 std::string function_definition; 6053 std::string function_use; 6054 std::string verification; 6055 6056 function_definition += "bool gfunc(" + var_iterator->second.type + " x[2][2][2][2][2][2][2][2], "; 6057 function_definition += "inout " + var_iterator->second.type + " y[2][2][2][2][2][2][2][2])\n"; 6058 function_definition += "{\n"; 6059 function_definition += " " + iteration_loop_start; 6060 function_definition += 6061 " y[a][b][c][d][e][f][g][h] = " + var_iterator->second.type + 6062 "(123);\n"; 6063 function_definition += " " + iteration_loop_end; 6064 function_definition += "\n"; 6065 function_definition += " " + iteration_loop_start; 6066 function_definition += " if(x[a][b][c][d][e][f][g][h]"; 6067 if (var_iterator->second.type == "mat4") // mat4 comparison 6068 { 6069 function_definition += "[0][0]"; 6070 function_definition += " != float"; 6071 } 6072 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 6073 { 6074 function_definition += "[0][0]"; 6075 function_definition += " != double"; 6076 } 6077 else 6078 { 6079 function_definition += " != "; 6080 function_definition += var_iterator->second.type; 6081 } 6082 function_definition += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h))) {return false;}\n"; 6083 function_definition += " " + iteration_loop_end; 6084 function_definition += " return true;\n"; 6085 function_definition += "}\n\n"; 6086 6087 function_use += " " + array_declaration; 6088 function_use += " " + iteration_loop_start; 6089 function_use += " z[a][b][c][d][e][f][g][h] = "; 6090 function_use += var_iterator->second.type; 6091 function_use += "(((a*128u)+(b*64u)+(c*32u)+(d*16u)+(e*8u)+(f*4u)+(g*2u)+h));\n"; 6092 function_use += " " + iteration_loop_end; 6093 6094 verification += " float result = 0.0;\n"; 6095 verification += " if(gfunc(z, z) == true)\n"; 6096 verification += " {\n"; 6097 verification += " result = 1.0;\n\n"; 6098 verification += " }\n"; 6099 verification += " else\n"; 6100 verification += " {\n"; 6101 verification += " result = 0.0;\n\n"; 6102 verification += " }\n"; 6103 6104 if (false == test_compute) 6105 { 6106 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification); 6107 } 6108 else 6109 { 6110 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification); 6111 } 6112 6113 /* Deallocate any resources used. */ 6114 this->delete_objects(); 6115 } /* if var_type iterator found */ 6116 else 6117 { 6118 TCU_FAIL("Type not found."); 6119 } 6120 } 6121 } 6122 6123 /* Generates the shader source code for the InteractionUniforms1 6124 * array tests, and attempts to compile each test shader, for both 6125 * vertex and fragment shaders. 6126 * 6127 * @tparam API Tested API descriptor 6128 * 6129 * @param tested_shader_type The type of shader that is being tested 6130 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 6131 */ 6132 template <class API> 6133 void InteractionUniforms1<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 6134 { 6135 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT }; 6136 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 6137 6138 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT, 6139 VAR_TYPE_DOUBLE }; 6140 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 6141 6142 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 6143 const glcts::test_var_type* var_types_set = var_types_set_es; 6144 size_t num_var_types = num_var_types_es; 6145 6146 if (API::USE_DOUBLE) 6147 { 6148 var_types_set = var_types_set_gl; 6149 num_var_types = num_var_types_gl; 6150 } 6151 6152 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 6153 { 6154 _supported_variable_types_map_const_iterator var_iterator = 6155 supported_variable_types_map.find(var_types_set[var_type_index]); 6156 6157 if (var_iterator != supported_variable_types_map.end()) 6158 { 6159 std::string uniform_definition; 6160 std::string uniform_use; 6161 6162 uniform_definition += "uniform "; 6163 uniform_definition += var_iterator->second.precision; 6164 uniform_definition += " "; 6165 uniform_definition += var_iterator->second.type; 6166 uniform_definition += " my_uniform_1[1][1][1][1];\n\n"; 6167 6168 uniform_use = " float result = float(my_uniform_1[0][0][0][0]);\n"; 6169 6170 if (API::USE_ALL_SHADER_STAGES) 6171 { 6172 const std::string& compute_shader_source = 6173 this->prepare_compute_shader(tested_shader_type, uniform_definition, uniform_use); 6174 const std::string& fragment_shader_source = 6175 this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use); 6176 const std::string& geometry_shader_source = 6177 this->prepare_geometry_shader(tested_shader_type, uniform_definition, uniform_use); 6178 const std::string& tess_ctrl_shader_source = 6179 this->prepare_tess_ctrl_shader(tested_shader_type, uniform_definition, uniform_use); 6180 const std::string& tess_eval_shader_source = 6181 this->prepare_tess_eval_shader(tested_shader_type, uniform_definition, uniform_use); 6182 const std::string& vertex_shader_source = 6183 this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use); 6184 6185 switch (tested_shader_type) 6186 { 6187 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 6188 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 6189 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 6190 break; 6191 6192 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 6193 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 6194 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 6195 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 6196 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 6197 geometry_shader_source, fragment_shader_source, compute_shader_source, 6198 false, false); 6199 break; 6200 6201 default: 6202 TCU_FAIL("Invalid enum"); 6203 break; 6204 } 6205 } 6206 else 6207 { 6208 const std::string& fragment_shader_source = 6209 this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use); 6210 const std::string& vertex_shader_source = 6211 this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use); 6212 6213 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 6214 } 6215 6216 glw::GLint uniform_location = -1; 6217 6218 /* Make program object active. */ 6219 gl.useProgram(this->program_object_id); 6220 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 6221 6222 /* Get uniform location. */ 6223 uniform_location = gl.getUniformLocation(this->program_object_id, "my_uniform_1[0][0][0][0]"); 6224 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed."); 6225 6226 if (uniform_location == -1) 6227 { 6228 TCU_FAIL("Uniform is not found or is considered as not active."); 6229 } 6230 6231 switch (var_type_index) 6232 { 6233 case 0: //float type of uniform is considered 6234 { 6235 glw::GLfloat uniform_value = 1.0f; 6236 6237 gl.uniform1f(uniform_location, uniform_value); 6238 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1f() failed."); 6239 6240 break; 6241 } 6242 case 1: //int type of uniform is considered 6243 { 6244 glw::GLint uniform_value = 1; 6245 6246 gl.uniform1i(uniform_location, uniform_value); 6247 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed."); 6248 6249 break; 6250 } 6251 case 2: //uint type of uniform is considered 6252 { 6253 glw::GLuint uniform_value = 1; 6254 6255 gl.uniform1ui(uniform_location, uniform_value); 6256 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1ui() failed."); 6257 6258 break; 6259 } 6260 case 3: //double type of uniform is considered 6261 { 6262 glw::GLdouble uniform_value = 1.0; 6263 6264 gl.uniform1d(uniform_location, uniform_value); 6265 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1d() failed."); 6266 6267 break; 6268 } 6269 default: 6270 { 6271 TCU_FAIL("Invalid variable-type index."); 6272 6273 break; 6274 } 6275 } /* switch (var_type_index) */ 6276 6277 /* Deallocate any resources used. */ 6278 this->delete_objects(); 6279 } /* if var_type iterator found */ 6280 else 6281 { 6282 TCU_FAIL("Type not found."); 6283 } 6284 } /* for (int var_type_index = 0; ...) */ 6285 } 6286 6287 /** Prepare shader 6288 * 6289 * @tparam API Tested API descriptor 6290 * 6291 * @param tested_shader_type The type of shader that is being tested 6292 * @param uniform_definition Definition used to prepare shader 6293 * @param uniform_use Snippet that use defined uniform 6294 **/ 6295 template <class API> 6296 std::string InteractionUniforms1<API>::prepare_compute_shader( 6297 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& uniform_definition, 6298 const std::string& uniform_use) 6299 { 6300 std::string compute_shader_source; 6301 6302 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type) 6303 { 6304 compute_shader_source = "writeonly uniform image2D uni_image;\n" 6305 "\n"; 6306 6307 /* User-defined function definition. */ 6308 compute_shader_source += uniform_definition; 6309 compute_shader_source += "\n\n"; 6310 6311 /* Main function definition. */ 6312 compute_shader_source += shader_start; 6313 compute_shader_source += uniform_use; 6314 compute_shader_source += "\n\n"; 6315 compute_shader_source += "\n" 6316 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n" 6317 "}\n" 6318 "\n"; 6319 } 6320 6321 return compute_shader_source; 6322 } 6323 6324 /** Prepare shader 6325 * 6326 * @tparam API Tested API descriptor 6327 * 6328 * @param tested_shader_type The type of shader that is being tested 6329 * @param uniform_definition Definition used to prepare shader 6330 * @param uniform_use Snippet that use defined uniform 6331 **/ 6332 template <class API> 6333 std::string InteractionUniforms1<API>::prepare_fragment_shader( 6334 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& uniform_definition, 6335 const std::string& uniform_use) 6336 { 6337 std::string fragment_shader_source; 6338 6339 switch (tested_shader_type) 6340 { 6341 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 6342 break; 6343 6344 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 6345 fragment_shader_source = "out vec4 colour;\n\n"; 6346 6347 /* User-defined function definition. */ 6348 fragment_shader_source += uniform_definition; 6349 fragment_shader_source += "\n\n"; 6350 6351 /* Main function definition. */ 6352 fragment_shader_source += shader_start; 6353 fragment_shader_source += uniform_use; 6354 fragment_shader_source += "\n\n"; 6355 fragment_shader_source += " colour = vec4(result);\n"; 6356 fragment_shader_source += shader_end; 6357 break; 6358 6359 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 6360 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 6361 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 6362 fragment_shader_source = "in float fs_result;\n\n" 6363 "out vec4 colour;\n\n" 6364 "void main()\n" 6365 "{\n" 6366 " colour = vec4(fs_result);\n" 6367 "}\n" 6368 "\n"; 6369 break; 6370 6371 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 6372 fragment_shader_source = default_fragment_shader_source; 6373 break; 6374 6375 default: 6376 TCU_FAIL("Unrecognized shader object type."); 6377 break; 6378 } 6379 6380 return fragment_shader_source; 6381 } 6382 6383 /** Prepare shader 6384 * 6385 * @tparam API Tested API descriptor 6386 * 6387 * @param tested_shader_type The type of shader that is being tested 6388 * @param uniform_definition Definition used to prepare shader 6389 * @param uniform_use Snippet that use defined uniform 6390 **/ 6391 template <class API> 6392 std::string InteractionUniforms1<API>::prepare_geometry_shader( 6393 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& uniform_definition, 6394 const std::string& uniform_use) 6395 { 6396 std::string geometry_shader_source; 6397 6398 switch (tested_shader_type) 6399 { 6400 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 6401 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 6402 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 6403 break; 6404 6405 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 6406 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 6407 geometry_shader_source = "layout(points) in;\n" 6408 "layout(triangle_strip, max_vertices = 4) out;\n" 6409 "\n" 6410 "in float tes_result[];\n" 6411 "out float fs_result;\n" 6412 "\n" 6413 "void main()\n" 6414 "{\n" 6415 " gl_Position = vec4(-1, -1, 0, 1);\n" 6416 " fs_result = tes_result[0];\n" 6417 " EmitVertex();\n" 6418 " gl_Position = vec4(-1, 1, 0, 1);\n" 6419 " fs_result = tes_result[0];\n" 6420 " EmitVertex();\n" 6421 " gl_Position = vec4(1, -1, 0, 1);\n" 6422 " fs_result = tes_result[0];\n" 6423 " EmitVertex();\n" 6424 " gl_Position = vec4(1, 1, 0, 1);\n" 6425 " fs_result = tes_result[0];\n" 6426 " EmitVertex();\n" 6427 "}\n"; 6428 break; 6429 6430 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 6431 geometry_shader_source = "layout(points) in;\n" 6432 "layout(triangle_strip, max_vertices = 4) out;\n" 6433 "\n" 6434 "out float fs_result;\n" 6435 "\n"; 6436 6437 /* User-defined function definition. */ 6438 geometry_shader_source += uniform_definition; 6439 geometry_shader_source += "\n\n"; 6440 6441 /* Main function definition. */ 6442 geometry_shader_source += shader_start; 6443 geometry_shader_source += uniform_use; 6444 geometry_shader_source += "\n\n"; 6445 geometry_shader_source += "\n gl_Position = vec4(-1, -1, 0, 1);\n" 6446 " fs_result = result;\n" 6447 " EmitVertex();\n" 6448 " gl_Position = vec4(-1, 1, 0, 1);\n" 6449 " fs_result = result;\n" 6450 " EmitVertex();\n" 6451 " gl_Position = vec4(1, -1, 0, 1);\n" 6452 " fs_result = result;\n" 6453 " EmitVertex();\n" 6454 " gl_Position = vec4(1, 1, 0, 1);\n" 6455 " fs_result = result;\n" 6456 " EmitVertex();\n" 6457 "}\n"; 6458 break; 6459 6460 default: 6461 TCU_FAIL("Unrecognized shader object type."); 6462 break; 6463 } 6464 6465 return geometry_shader_source; 6466 } 6467 6468 /** Prepare shader 6469 * 6470 * @tparam API Tested API descriptor 6471 * 6472 * @param tested_shader_type The type of shader that is being tested 6473 * @param uniform_definition Definition used to prepare shader 6474 * @param uniform_use Snippet that use defined uniform 6475 **/ 6476 template <class API> 6477 std::string InteractionUniforms1<API>::prepare_tess_ctrl_shader( 6478 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& uniform_definition, 6479 const std::string& uniform_use) 6480 { 6481 std::string tess_ctrl_shader_source; 6482 6483 switch (tested_shader_type) 6484 { 6485 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 6486 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 6487 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 6488 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 6489 break; 6490 6491 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 6492 tess_ctrl_shader_source = "layout(vertices = 1) out;\n" 6493 "\n" 6494 "out float tcs_result[];\n" 6495 "\n"; 6496 6497 /* User-defined function definition. */ 6498 tess_ctrl_shader_source += uniform_definition; 6499 tess_ctrl_shader_source += "\n\n"; 6500 6501 /* Main function definition. */ 6502 tess_ctrl_shader_source += shader_start; 6503 tess_ctrl_shader_source += uniform_use; 6504 tess_ctrl_shader_source += "\n\n"; 6505 tess_ctrl_shader_source += " tcs_result[gl_InvocationID] = result;\n" 6506 "\n" 6507 " gl_TessLevelOuter[0] = 1.0;\n" 6508 " gl_TessLevelOuter[1] = 1.0;\n" 6509 " gl_TessLevelOuter[2] = 1.0;\n" 6510 " gl_TessLevelOuter[3] = 1.0;\n" 6511 " gl_TessLevelInner[0] = 1.0;\n" 6512 " gl_TessLevelInner[1] = 1.0;\n" 6513 "}\n"; 6514 break; 6515 6516 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 6517 tess_ctrl_shader_source = default_tc_shader_source; 6518 break; 6519 6520 default: 6521 TCU_FAIL("Unrecognized shader object type."); 6522 break; 6523 } 6524 6525 return tess_ctrl_shader_source; 6526 } 6527 6528 /** Prepare shader 6529 * 6530 * @tparam API Tested API descriptor 6531 * 6532 * @param tested_shader_type The type of shader that is being tested 6533 * @param uniform_definition Definition used to prepare shader 6534 * @param uniform_use Snippet that use defined uniform 6535 **/ 6536 template <class API> 6537 std::string InteractionUniforms1<API>::prepare_tess_eval_shader( 6538 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& uniform_definition, 6539 const std::string& uniform_use) 6540 { 6541 std::string tess_eval_shader_source; 6542 6543 switch (tested_shader_type) 6544 { 6545 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 6546 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 6547 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 6548 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 6549 break; 6550 6551 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 6552 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 6553 "\n" 6554 "in float tcs_result[];\n" 6555 "out float tes_result;\n" 6556 "\n" 6557 "void main()\n" 6558 "{\n" 6559 " tes_result = tcs_result[0];\n" 6560 "}\n"; 6561 break; 6562 6563 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 6564 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 6565 "\n" 6566 "out float tes_result;\n" 6567 "\n"; 6568 6569 /* User-defined function definition. */ 6570 tess_eval_shader_source += uniform_definition; 6571 tess_eval_shader_source += "\n\n"; 6572 6573 /* Main function definition. */ 6574 tess_eval_shader_source += shader_start; 6575 tess_eval_shader_source += uniform_use; 6576 tess_eval_shader_source += "\n\n"; 6577 tess_eval_shader_source += " tes_result = result;\n" 6578 "}\n"; 6579 break; 6580 6581 default: 6582 TCU_FAIL("Unrecognized shader object type."); 6583 break; 6584 } 6585 6586 return tess_eval_shader_source; 6587 } 6588 6589 /** Prepare shader 6590 * 6591 * @tparam API Tested API descriptor 6592 * 6593 * @param tested_shader_type The type of shader that is being tested 6594 * @param uniform_definition Definition used to prepare shader 6595 * @param uniform_use Snippet that use defined uniform 6596 **/ 6597 template <class API> 6598 std::string InteractionUniforms1<API>::prepare_vertex_shader( 6599 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& uniform_definition, 6600 const std::string& uniform_use) 6601 { 6602 std::string vertex_shader_source; 6603 6604 switch (tested_shader_type) 6605 { 6606 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 6607 break; 6608 6609 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 6610 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 6611 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 6612 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 6613 vertex_shader_source = default_vertex_shader_source; 6614 break; 6615 6616 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 6617 /* User-defined function definition. */ 6618 vertex_shader_source += uniform_definition; 6619 6620 /* Main function definition. */ 6621 vertex_shader_source += shader_start; 6622 vertex_shader_source += uniform_use; 6623 vertex_shader_source += " gl_Position = vec4(result);\n"; 6624 vertex_shader_source += shader_end; 6625 break; 6626 6627 default: 6628 TCU_FAIL("Unrecognized shader object type."); 6629 break; 6630 } 6631 6632 return vertex_shader_source; 6633 } 6634 6635 /* Generates the shader source code for the InteractionUniforms2 6636 * array tests, and attempts to compile each test shader, for both 6637 * vertex and fragment shaders. 6638 * 6639 * @tparam API Tested API descriptor 6640 * 6641 * @param tested_shader_type The type of shader that is being tested 6642 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 6643 */ 6644 template <class API> 6645 void InteractionUniforms2<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 6646 { 6647 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4 }; 6648 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 6649 6650 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_MAT4, 6651 VAR_TYPE_DOUBLE, VAR_TYPE_DMAT4 }; 6652 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 6653 6654 const std::string array_initializers[] = { "int[2][2][2][2](\n" 6655 " int[2][2][2](\n" 6656 " int[2][2](\n" 6657 " int[2]( 1, 2),\n" 6658 " int[2]( 3, 4)\n" 6659 " ),\n" 6660 " int[2][2](\n" 6661 " int[2]( 5, 6),\n" 6662 " int[2]( 7, 8)\n" 6663 " )\n" 6664 " ),\n" 6665 " int[2][2][2](\n" 6666 " int[2][2](\n" 6667 " int[2](11, 12),\n" 6668 " int[2](13, 14)\n" 6669 " ),\n" 6670 " int[2][2](\n" 6671 " int[2](15, 16),\n" 6672 " int[2](17, 18)\n" 6673 " )\n" 6674 " )\n" 6675 ")", 6676 6677 "float[2][2][2][2](\n" 6678 " float[2][2][2](\n" 6679 " float[2][2](\n" 6680 " float[2](1.0, 2.0),\n" 6681 " float[2](3.0, 4.0)),\n" 6682 " float[2][2](\n" 6683 " float[2](5.0, 6.0),\n" 6684 " float[2](7.0, 8.0))),\n" 6685 " float[2][2][2](\n" 6686 " float[2][2](\n" 6687 " float[2](1.1, 2.1),\n" 6688 " float[2](3.1, 4.1)\n" 6689 " ),\n" 6690 " float[2][2](\n" 6691 " float[2](5.1, 6.1),\n" 6692 " float[2](7.1, 8.1)\n" 6693 " )\n" 6694 " )\n" 6695 ")", 6696 6697 "mat4[2][2][2][2](\n" 6698 " mat4[2][2][2](\n" 6699 " mat4[2][2](\n" 6700 " mat4[2]( mat4(1), mat4(2)),\n" 6701 " mat4[2]( mat4(3), mat4(4))\n" 6702 " ),\n" 6703 " mat4[2][2](\n" 6704 " mat4[2](mat4(5), mat4(6)),\n" 6705 " mat4[2](mat4(7), mat4(8))\n" 6706 " )\n" 6707 " ),\n" 6708 " mat4[2][2][2](\n" 6709 " mat4[2][2](\n" 6710 " mat4[2](mat4(9), mat4(10)),\n" 6711 " mat4[2](mat4(11), mat4(12))\n" 6712 " ),\n" 6713 " mat4[2][2](\n" 6714 " mat4[2](mat4(13), mat4(14)),\n" 6715 " mat4[2](mat4(15), mat4(16))\n" 6716 " )\n" 6717 " )\n" 6718 ")", 6719 6720 "double[2][2][2][2](\n" 6721 " double[2][2][2](\n" 6722 " double[2][2](\n" 6723 " double[2](1.0, 2.0),\n" 6724 " double[2](3.0, 4.0)),\n" 6725 " double[2][2](\n" 6726 " double[2](5.0, 6.0),\n" 6727 " double[2](7.0, 8.0))),\n" 6728 " double[2][2][2](\n" 6729 " double[2][2](\n" 6730 " double[2](1.1, 2.1),\n" 6731 " double[2](3.1, 4.1)\n" 6732 " ),\n" 6733 " double[2][2](\n" 6734 " double[2](5.1, 6.1),\n" 6735 " double[2](7.1, 8.1)\n" 6736 " )\n" 6737 " )\n" 6738 ")", 6739 6740 "dmat4[2][2][2][2](\n" 6741 " dmat4[2][2][2](\n" 6742 " dmat4[2][2](\n" 6743 " dmat4[2]( dmat4(1), dmat4(2)),\n" 6744 " dmat4[2]( dmat4(3), dmat4(4))\n" 6745 " ),\n" 6746 " dmat4[2][2](\n" 6747 " dmat4[2](dmat4(5), dmat4(6)),\n" 6748 " dmat4[2](dmat4(7), dmat4(8))\n" 6749 " )\n" 6750 " ),\n" 6751 " dmat4[2][2][2](\n" 6752 " dmat4[2][2](\n" 6753 " dmat4[2](dmat4(9), dmat4(10)),\n" 6754 " dmat4[2](dmat4(11), dmat4(12))\n" 6755 " ),\n" 6756 " dmat4[2][2](\n" 6757 " dmat4[2](dmat4(13), dmat4(14)),\n" 6758 " dmat4[2](dmat4(15), dmat4(16))\n" 6759 " )\n" 6760 " )\n" 6761 ")" }; 6762 6763 const glcts::test_var_type* var_types_set = var_types_set_es; 6764 size_t num_var_types = num_var_types_es; 6765 6766 if (API::USE_DOUBLE) 6767 { 6768 var_types_set = var_types_set_gl; 6769 num_var_types = num_var_types_gl; 6770 } 6771 6772 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 6773 { 6774 _supported_variable_types_map_const_iterator var_iterator = 6775 supported_variable_types_map.find(var_types_set[var_type_index]); 6776 6777 if (var_iterator != supported_variable_types_map.end()) 6778 { 6779 std::string base_variable_string; 6780 6781 for (int initialiser_selector = 1; initialiser_selector >= 0; initialiser_selector--) 6782 { 6783 // We normally do all 16 possible permutations of [4][4][4][4] items (15..0). 6784 // However, in this case we will skip the case that will work, 6785 // so we'll merely process permutations 14..0 6786 for (int permutation_index = 14; permutation_index >= 0; permutation_index--) 6787 { 6788 base_variable_string = 6789 "uniform " + var_iterator->second.precision + " " + var_iterator->second.type + " x"; 6790 6791 // for all 4 possible sub_script entries 6792 for (int sub_script_entry_index = 3; sub_script_entry_index >= 0; sub_script_entry_index--) 6793 { 6794 if (permutation_index & (1 << sub_script_entry_index)) 6795 { 6796 // In this case, we'll use a valid sub_script 6797 base_variable_string += "[2]"; 6798 } 6799 else 6800 { 6801 // In this case, we'll use an invalid sub_script 6802 base_variable_string += "[]"; 6803 } 6804 } 6805 6806 if (initialiser_selector == 0) 6807 { 6808 // We'll use an initialiser 6809 base_variable_string += " = " + array_initializers[var_type_index]; 6810 } 6811 6812 base_variable_string += ";\n\n"; 6813 6814 std::string shader_source = base_variable_string + shader_start; 6815 6816 /* End main */ 6817 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 6818 6819 /* Execute test: 6820 * 6821 * This will succeed in case of allowed unsized 6822 * declarations and when at least one of these is 6823 * true: 6824 * 1. There is an initialiser. 6825 * 2. Only the outermost dimension is unsized, 6826 * as in [][2][2][2]. 6827 */ 6828 EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION && 6829 (initialiser_selector == 0 || permutation_index == 7), 6830 tested_shader_type, shader_source); 6831 } /* for (int permutation_index = 14; ...) */ 6832 } /* for (int initialiser_selector = 1; ...) */ 6833 } /* if var_type iterator found */ 6834 else 6835 { 6836 TCU_FAIL("Type not found."); 6837 } 6838 } /* for (int var_type_index = 0; ...) */ 6839 } 6840 6841 /* Generates the shader source code for the InteractionUniformBuffers1 6842 * array tests, and attempts to compile each test shader, for both 6843 * vertex and fragment shaders. 6844 * 6845 * @tparam API Tested API descriptor 6846 * 6847 * @param tested_shader_type The type of shader that is being tested 6848 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 6849 */ 6850 template <class API> 6851 void InteractionUniformBuffers1<API>::test_shader_compilation( 6852 typename TestCaseBase<API>::TestShaderType tested_shader_type) 6853 { 6854 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT }; 6855 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 6856 6857 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT, 6858 VAR_TYPE_DOUBLE }; 6859 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 6860 6861 const glcts::test_var_type* var_types_set = var_types_set_es; 6862 size_t num_var_types = num_var_types_es; 6863 6864 if (API::USE_DOUBLE) 6865 { 6866 var_types_set = var_types_set_gl; 6867 num_var_types = num_var_types_gl; 6868 } 6869 6870 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 6871 { 6872 _supported_variable_types_map_const_iterator var_iterator = 6873 supported_variable_types_map.find(var_types_set[var_type_index]); 6874 6875 if (var_iterator != supported_variable_types_map.end()) 6876 { 6877 std::string shader_source; 6878 6879 shader_source += "uniform uBlocka {\n"; 6880 shader_source += " " + var_iterator->second.type + " x[1][1][1][1][1][1];\n"; 6881 shader_source += "};\n\n"; 6882 shader_source += shader_start; 6883 6884 /* End main */ 6885 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 6886 6887 /* Execute test */ 6888 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 6889 } /* if var_type iterator found */ 6890 else 6891 { 6892 TCU_FAIL("Type not found."); 6893 } 6894 } 6895 } 6896 6897 /* Generates the shader source code for the InteractionUniformBuffers2 6898 * array tests, and attempts to compile each test shader, for both 6899 * vertex and fragment shaders. 6900 * 6901 * @tparam API Tested API descriptor 6902 * 6903 * @param tested_shader_type The type of shader that is being tested 6904 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 6905 */ 6906 template <class API> 6907 void InteractionUniformBuffers2<API>::test_shader_compilation( 6908 typename TestCaseBase<API>::TestShaderType tested_shader_type) 6909 { 6910 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT }; 6911 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 6912 6913 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT, 6914 VAR_TYPE_DOUBLE }; 6915 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 6916 6917 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 6918 const glcts::test_var_type* var_types_set = var_types_set_es; 6919 size_t num_var_types = num_var_types_es; 6920 6921 if (API::USE_DOUBLE) 6922 { 6923 var_types_set = var_types_set_gl; 6924 num_var_types = num_var_types_gl; 6925 } 6926 6927 /* Iterate through float / int / uint values. */ 6928 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 6929 { 6930 _supported_variable_types_map_const_iterator var_iterator = 6931 supported_variable_types_map.find(var_types_set[var_type_index]); 6932 6933 if (var_iterator != supported_variable_types_map.end()) 6934 { 6935 std::string uniform_definition; 6936 std::string uniform_use; 6937 6938 uniform_definition += "layout (std140) uniform uniform_block_name\n" 6939 "{\n"; 6940 uniform_definition += " "; 6941 uniform_definition += var_iterator->second.type; 6942 uniform_definition += " my_uniform_1[1][1][1][1];\n" 6943 "};\n"; 6944 6945 uniform_use = " float result = float(my_uniform_1[0][0][0][0]);\n"; 6946 6947 if (API::USE_ALL_SHADER_STAGES) 6948 { 6949 const std::string& compute_shader_source = 6950 this->prepare_compute_shader(tested_shader_type, uniform_definition, uniform_use); 6951 const std::string& fragment_shader_source = 6952 this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use); 6953 const std::string& geometry_shader_source = 6954 this->prepare_geometry_shader(tested_shader_type, uniform_definition, uniform_use); 6955 const std::string& tess_ctrl_shader_source = 6956 this->prepare_tess_ctrl_shader(tested_shader_type, uniform_definition, uniform_use); 6957 const std::string& tess_eval_shader_source = 6958 this->prepare_tess_eval_shader(tested_shader_type, uniform_definition, uniform_use); 6959 const std::string& vertex_shader_source = 6960 this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use); 6961 6962 switch (tested_shader_type) 6963 { 6964 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 6965 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 6966 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 6967 break; 6968 6969 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 6970 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 6971 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 6972 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 6973 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 6974 geometry_shader_source, fragment_shader_source, compute_shader_source, 6975 false, false); 6976 break; 6977 6978 default: 6979 TCU_FAIL("Invalid enum"); 6980 break; 6981 } 6982 } 6983 else 6984 { 6985 const std::string& fragment_shader_source = 6986 this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use); 6987 const std::string& vertex_shader_source = 6988 this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use); 6989 6990 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 6991 } 6992 6993 glw::GLuint buffer_object_id = 0; 6994 glw::GLint my_uniform_block_index = GL_INVALID_INDEX; 6995 6996 gl.useProgram(this->program_object_id); 6997 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 6998 6999 my_uniform_block_index = gl.getUniformBlockIndex(this->program_object_id, "uniform_block_name"); 7000 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformBlockIndex() failed."); 7001 7002 if ((unsigned)my_uniform_block_index == GL_INVALID_INDEX) 7003 { 7004 TCU_FAIL("Uniform block not found or is considered as not active."); 7005 } 7006 7007 gl.genBuffers(1, &buffer_object_id); 7008 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed."); 7009 7010 gl.bindBuffer(GL_UNIFORM_BUFFER, buffer_object_id); 7011 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() failed."); 7012 7013 switch (var_type_index) 7014 { 7015 case 0: //float type of uniform is considered 7016 { 7017 glw::GLfloat buffer_data[] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 7018 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f }; 7019 7020 gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7021 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7022 7023 break; 7024 } /* float case */ 7025 case 1: //int type of uniform is considered 7026 { 7027 7028 glw::GLint buffer_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; 7029 7030 gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7031 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7032 7033 break; 7034 } /* int case */ 7035 case 2: //uint type of uniform is considered 7036 { 7037 glw::GLuint buffer_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; 7038 7039 gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7040 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7041 7042 break; 7043 } /* uint case */ 7044 case 3: //double type of uniform is considered 7045 { 7046 glw::GLdouble buffer_data[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 7047 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0 }; 7048 7049 gl.bufferData(GL_UNIFORM_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7050 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7051 7052 break; 7053 } /* double case */ 7054 default: 7055 { 7056 TCU_FAIL("Invalid variable-type index."); 7057 7058 break; 7059 } 7060 } /* switch (var_type_index) */ 7061 7062 gl.uniformBlockBinding(this->program_object_id, my_uniform_block_index, 0); 7063 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformBlockBinding() failed."); 7064 7065 gl.bindBufferBase(GL_UNIFORM_BUFFER, 0, buffer_object_id); 7066 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() failed."); 7067 7068 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != tested_shader_type) 7069 { 7070 execute_draw_test(tested_shader_type); 7071 } 7072 else 7073 { 7074 execute_dispatch_test(); 7075 } 7076 7077 /* Deallocate any resources used. */ 7078 gl.deleteBuffers(1, &buffer_object_id); 7079 this->delete_objects(); 7080 } /* if var_type iterator found */ 7081 else 7082 { 7083 TCU_FAIL("Type not found."); 7084 } 7085 } /* for (int var_type_index = 0; ...) */ 7086 } 7087 7088 /** Executes test for compute program 7089 * 7090 * @tparam API Tested API descriptor 7091 **/ 7092 template <class API> 7093 void InteractionUniformBuffers2<API>::execute_dispatch_test() 7094 { 7095 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 7096 7097 gl.dispatchCompute(1, 1, 1); 7098 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 7099 } 7100 7101 /** Executes test for draw program 7102 * 7103 * @tparam API Tested API descriptor 7104 * 7105 * @param tested_shader_type The type of shader that is being tested 7106 **/ 7107 template <class API> 7108 void InteractionUniformBuffers2<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type) 7109 { 7110 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 7111 7112 glw::GLuint vao_id = 0; 7113 7114 gl.genVertexArrays(1, &vao_id); 7115 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 7116 7117 gl.bindVertexArray(vao_id); 7118 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 7119 7120 switch (tested_shader_type) 7121 { 7122 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 7123 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 7124 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 7125 gl.drawArrays(GL_POINTS, 0, 1); 7126 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 7127 break; 7128 7129 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 7130 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 7131 /* Tesselation patch set up */ 7132 gl.patchParameteri(GL_PATCH_VERTICES, 1); 7133 GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); 7134 7135 gl.drawArrays(GL_PATCHES, 0, 1); 7136 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 7137 break; 7138 7139 default: 7140 TCU_FAIL("Invalid enum"); 7141 break; 7142 } 7143 7144 gl.deleteVertexArrays(1, &vao_id); 7145 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays() failed."); 7146 } 7147 7148 /* Generates the shader source code for the InteractionUniformBuffers3 7149 * array tests, and attempts to compile each test shader, for both 7150 * vertex and fragment shaders. 7151 * 7152 * @tparam API Tested API descriptor 7153 * 7154 * @param tested_shader_type The type of shader that is being tested 7155 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 7156 */ 7157 template <class API> 7158 void InteractionUniformBuffers3<API>::test_shader_compilation( 7159 typename TestCaseBase<API>::TestShaderType tested_shader_type) 7160 { 7161 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT }; 7162 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 7163 7164 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT, 7165 VAR_TYPE_DOUBLE }; 7166 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 7167 7168 const std::string invalid_size_declarations[] = { "[2][2][2][]", "[2][2][][2]", "[2][][2][2]", "[][2][2][2]", 7169 "[2][2][][]", "[2][][2][]", "[][2][2][]", "[2][][][2]", 7170 "[][2][][2]", "[][][2][2]", "[2][][][]", "[][2][][]", 7171 "[][][2][]", "[][][][2]", "[][][][]" }; 7172 7173 const std::string array_initializers[] = { "float[2][2][2][2](float[2][2][2](float[2][2](float[2](1.0, 2.0)," 7174 "float[2](3.0, 4.0))," 7175 "float[2][2](float[2](5.0, 6.0)," 7176 "float[2](7.0, 8.0)))," 7177 "float[2][2][2](float[2][2](float[2](1.1, 2.1)," 7178 "float[2](3.1, 4.1))," 7179 "float[2][2](float[2](5.1, 6.1)," 7180 "float[2](7.1, 8.1))));\n", 7181 7182 "int[2][2][2][2](int[2][2][2](int[2][2](int[2]( 1, 2)," 7183 "int[2]( 3, 4))," 7184 "int[2][2](int[2]( 5, 6)," 7185 "int[2]( 7, 8)))," 7186 "int[2][2][2](int[2][2](int[2](11, 12)," 7187 "int[2](13, 14))," 7188 "int[2][2](int[2](15, 16)," 7189 "int[2](17, 18))));\n", 7190 7191 "uint[2][2][2][2](uint[2][2][2](uint[2][2](uint[2]( 1u, 2u)," 7192 "uint[2]( 3u, 4u))," 7193 "uint[2][2](uint[2]( 5u, 6u)," 7194 "uint[2]( 7u, 8u)))," 7195 "uint[2][2][2](uint[2][2](uint[2](11u, 12u)," 7196 "uint[2](13u, 14u))," 7197 "uint[2][2](uint[2](15u, 16u)," 7198 "uint[2](17u, 18u))));\n", 7199 7200 "double[2][2][2][2](double[2][2][2](double[2][2](double[2](1.0, 2.0)," 7201 "double[2](3.0, 4.0))," 7202 "double[2][2](double[2](5.0, 6.0)," 7203 "double[2](7.0, 8.0)))," 7204 "double[2][2][2](double[2][2](double[2](1.1, 2.1)," 7205 "double[2](3.1, 4.1))," 7206 "double[2][2](double[2](5.1, 6.1)," 7207 "double[2](7.1, 8.1))));\n" }; 7208 const glcts::test_var_type* var_types_set = var_types_set_es; 7209 size_t num_var_types = num_var_types_es; 7210 7211 if (API::USE_DOUBLE) 7212 { 7213 var_types_set = var_types_set_gl; 7214 num_var_types = num_var_types_gl; 7215 } 7216 7217 /* Iterate through float/ int/ uint types. 7218 * Case: without initializer. 7219 */ 7220 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 7221 { 7222 _supported_variable_types_map_const_iterator var_iterator = 7223 supported_variable_types_map.find(var_types_set[var_type_index]); 7224 7225 if (var_iterator != supported_variable_types_map.end()) 7226 { 7227 for (size_t invalid_size_declarations_index = 0; 7228 invalid_size_declarations_index < 7229 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]); 7230 invalid_size_declarations_index++) 7231 { 7232 std::string shader_source; 7233 7234 shader_source = "layout (std140) uniform MyUniform {\n"; 7235 shader_source += " " + var_iterator->second.type + 7236 invalid_size_declarations[invalid_size_declarations_index] + " my_variable;\n"; 7237 shader_source += "};\n\n"; 7238 shader_source += shader_start; 7239 7240 /* End main */ 7241 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 7242 7243 /* Execute test */ 7244 EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION && invalid_size_declarations_index == 3, 7245 tested_shader_type, shader_source); 7246 } /* for (int invalid_size_declarations_index = 0; ...) */ 7247 } 7248 else 7249 { 7250 TCU_FAIL("Type not found."); 7251 } 7252 } /* for (int var_type_index = 0; ...) */ 7253 7254 /* Iterate through float/ int/ uint types. 7255 * Case: with initializer. 7256 */ 7257 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 7258 { 7259 _supported_variable_types_map_const_iterator var_iterator = 7260 supported_variable_types_map.find(var_types_set[var_type_index]); 7261 7262 if (var_iterator != supported_variable_types_map.end()) 7263 { 7264 for (size_t invalid_size_declarations_index = 0; 7265 invalid_size_declarations_index < 7266 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]); 7267 invalid_size_declarations_index++) 7268 { 7269 std::string shader_source; 7270 7271 shader_source = "layout (std140) uniform MyUniform {\n"; 7272 shader_source += " " + var_iterator->second.type + 7273 invalid_size_declarations[invalid_size_declarations_index] + 7274 " my_variable = " + array_initializers[var_type_index]; 7275 7276 var_iterator->second.type + invalid_size_declarations[invalid_size_declarations_index] + 7277 " my_variable = " + array_initializers[var_type_index]; 7278 shader_source += "};\n\n"; 7279 shader_source += shader_start; 7280 7281 /* End main */ 7282 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 7283 7284 /* Execute test */ 7285 this->execute_negative_test(tested_shader_type, shader_source); 7286 } /* for (int invalid_size_declarations_index = 0; ...) */ 7287 } /* if var_type iterator found */ 7288 else 7289 { 7290 TCU_FAIL("Type not found."); 7291 } 7292 } /* for (int var_type_index = 0; ...) */ 7293 } 7294 7295 /* Generates the shader source code for the InteractionStorageBuffers1 7296 * array tests, and attempts to compile each test shader, for both 7297 * vertex and fragment shaders. 7298 * 7299 * @tparam API Tested API descriptor 7300 * 7301 * @param tested_shader_type The type of shader that is being tested 7302 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 7303 */ 7304 template <class API> 7305 void InteractionStorageBuffers1<API>::test_shader_compilation( 7306 typename TestCaseBase<API>::TestShaderType tested_shader_type) 7307 { 7308 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT }; 7309 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 7310 7311 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT, 7312 VAR_TYPE_DOUBLE }; 7313 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 7314 7315 const glcts::test_var_type* var_types_set = var_types_set_es; 7316 size_t num_var_types = num_var_types_es; 7317 7318 if (API::USE_DOUBLE) 7319 { 7320 var_types_set = var_types_set_gl; 7321 num_var_types = num_var_types_gl; 7322 } 7323 7324 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 7325 { 7326 _supported_variable_types_map_const_iterator var_iterator = 7327 supported_variable_types_map.find(var_types_set[var_type_index]); 7328 7329 if (var_iterator != supported_variable_types_map.end()) 7330 { 7331 std::string shader_source; 7332 7333 shader_source += "buffer uBlocka {\n"; 7334 shader_source += " " + var_iterator->second.type + " x[1][1][1][1][1][1];\n"; 7335 shader_source += "};\n\n"; 7336 shader_source += shader_start; 7337 7338 /* End main */ 7339 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 7340 7341 /* Execute test */ 7342 EXECUTE_POSITIVE_TEST(tested_shader_type, shader_source, true, false); 7343 } /* if var_type iterator found */ 7344 else 7345 { 7346 TCU_FAIL("Type not found."); 7347 } 7348 } 7349 } 7350 7351 /* Generates the shader source code for the InteractionUniformBuffers2 7352 * array tests, and attempts to compile each test shader, for both 7353 * vertex and fragment shaders. 7354 * 7355 * @tparam API Tested API descriptor 7356 * 7357 * @param tested_shader_type The type of shader that is being tested 7358 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 7359 */ 7360 template <class API> 7361 void InteractionStorageBuffers2<API>::test_shader_compilation( 7362 typename TestCaseBase<API>::TestShaderType tested_shader_type) 7363 { 7364 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT }; 7365 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 7366 7367 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT, 7368 VAR_TYPE_DOUBLE }; 7369 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 7370 7371 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 7372 const glcts::test_var_type* var_types_set = var_types_set_es; 7373 size_t num_var_types = num_var_types_es; 7374 7375 if (API::USE_DOUBLE) 7376 { 7377 var_types_set = var_types_set_gl; 7378 num_var_types = num_var_types_gl; 7379 } 7380 7381 /* Iterate through float / int / uint values. */ 7382 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 7383 { 7384 _supported_variable_types_map_const_iterator var_iterator = 7385 supported_variable_types_map.find(var_types_set[var_type_index]); 7386 7387 if (var_iterator != supported_variable_types_map.end()) 7388 { 7389 std::string uniform_definition; 7390 std::string uniform_use; 7391 7392 uniform_definition += "layout (std140) buffer storage_block_name\n" 7393 "{\n"; 7394 uniform_definition += " "; 7395 uniform_definition += var_iterator->second.type; 7396 uniform_definition += " my_storage_1[1][1][1][1];\n" 7397 "};\n"; 7398 7399 uniform_use = " float result = float(my_storage_1[0][0][0][0]);\n"; 7400 7401 if (API::USE_ALL_SHADER_STAGES) 7402 { 7403 const std::string& compute_shader_source = 7404 this->prepare_compute_shader(tested_shader_type, uniform_definition, uniform_use); 7405 const std::string& fragment_shader_source = 7406 this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use); 7407 const std::string& geometry_shader_source = 7408 this->prepare_geometry_shader(tested_shader_type, uniform_definition, uniform_use); 7409 const std::string& tess_ctrl_shader_source = 7410 this->prepare_tess_ctrl_shader(tested_shader_type, uniform_definition, uniform_use); 7411 const std::string& tess_eval_shader_source = 7412 this->prepare_tess_eval_shader(tested_shader_type, uniform_definition, uniform_use); 7413 const std::string& vertex_shader_source = 7414 this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use); 7415 7416 switch (tested_shader_type) 7417 { 7418 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 7419 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 7420 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 7421 break; 7422 7423 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 7424 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 7425 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 7426 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 7427 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 7428 geometry_shader_source, fragment_shader_source, compute_shader_source, 7429 false, false); 7430 break; 7431 7432 default: 7433 TCU_FAIL("Invalid enum"); 7434 break; 7435 } 7436 } 7437 else 7438 { 7439 const std::string& fragment_shader_source = 7440 this->prepare_fragment_shader(tested_shader_type, uniform_definition, uniform_use); 7441 const std::string& vertex_shader_source = 7442 this->prepare_vertex_shader(tested_shader_type, uniform_definition, uniform_use); 7443 7444 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 7445 } 7446 7447 glw::GLuint buffer_object_id = 0; 7448 glw::GLint my_storage_block_index = GL_INVALID_INDEX; 7449 7450 gl.useProgram(this->program_object_id); 7451 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 7452 7453 my_storage_block_index = 7454 gl.getProgramResourceIndex(this->program_object_id, GL_SHADER_STORAGE_BLOCK, "storage_block_name"); 7455 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramResourceIndex() failed."); 7456 7457 if ((unsigned)my_storage_block_index == GL_INVALID_INDEX) 7458 { 7459 TCU_FAIL("Uniform block not found or is considered as not active."); 7460 } 7461 7462 gl.genBuffers(1, &buffer_object_id); 7463 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed."); 7464 7465 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer_object_id); 7466 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() failed."); 7467 7468 switch (var_type_index) 7469 { 7470 case 0: //float type of uniform is considered 7471 { 7472 glw::GLfloat buffer_data[] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 7473 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f }; 7474 7475 gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7476 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7477 7478 break; 7479 } /* float case */ 7480 case 1: //int type of uniform is considered 7481 { 7482 7483 glw::GLint buffer_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; 7484 7485 gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7486 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7487 7488 break; 7489 } /* int case */ 7490 case 2: //uint type of uniform is considered 7491 { 7492 glw::GLuint buffer_data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; 7493 7494 gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7495 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7496 7497 break; 7498 } /* uint case */ 7499 case 3: //double type of uniform is considered 7500 { 7501 glw::GLdouble buffer_data[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 7502 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0 }; 7503 7504 gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), buffer_data, GL_STATIC_DRAW); 7505 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 7506 7507 break; 7508 } /* double case */ 7509 default: 7510 { 7511 TCU_FAIL("Invalid variable-type index."); 7512 7513 break; 7514 } 7515 } /* switch (var_type_index) */ 7516 7517 gl.shaderStorageBlockBinding(this->program_object_id, my_storage_block_index, 0); 7518 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformBlockBinding() failed."); 7519 7520 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, buffer_object_id); 7521 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() failed."); 7522 7523 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != tested_shader_type) 7524 { 7525 execute_draw_test(tested_shader_type); 7526 } 7527 else 7528 { 7529 execute_dispatch_test(); 7530 } 7531 7532 /* Deallocate any resources used. */ 7533 gl.deleteBuffers(1, &buffer_object_id); 7534 this->delete_objects(); 7535 } /* if var_type iterator found */ 7536 else 7537 { 7538 TCU_FAIL("Type not found."); 7539 } 7540 } /* for (int var_type_index = 0; ...) */ 7541 } 7542 7543 /** Executes test for compute program 7544 * 7545 * @tparam API Tested API descriptor 7546 **/ 7547 template <class API> 7548 void InteractionStorageBuffers2<API>::execute_dispatch_test() 7549 { 7550 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 7551 7552 gl.dispatchCompute(1, 1, 1); 7553 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 7554 } 7555 7556 /** Executes test for draw program 7557 * 7558 * @tparam API Tested API descriptor 7559 * 7560 * @param tested_shader_type The type of shader that is being tested 7561 **/ 7562 template <class API> 7563 void InteractionStorageBuffers2<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type) 7564 { 7565 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 7566 7567 glw::GLuint vao_id = 0; 7568 7569 gl.genVertexArrays(1, &vao_id); 7570 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 7571 7572 gl.bindVertexArray(vao_id); 7573 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 7574 7575 switch (tested_shader_type) 7576 { 7577 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 7578 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 7579 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 7580 gl.drawArrays(GL_POINTS, 0, 1); 7581 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 7582 break; 7583 7584 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 7585 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 7586 /* Tesselation patch set up */ 7587 gl.patchParameteri(GL_PATCH_VERTICES, 1); 7588 GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); 7589 7590 gl.drawArrays(GL_PATCHES, 0, 1); 7591 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 7592 break; 7593 7594 default: 7595 TCU_FAIL("Invalid enum"); 7596 break; 7597 } 7598 7599 gl.deleteVertexArrays(1, &vao_id); 7600 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays() failed."); 7601 } 7602 7603 /* Generates the shader source code for the InteractionUniformBuffers3 7604 * array tests, and attempts to compile each test shader, for both 7605 * vertex and fragment shaders. 7606 * 7607 * @tparam API Tested API descriptor 7608 * 7609 * @param tested_shader_type The type of shader that is being tested 7610 * (either TestCaseBase<API>::VERTEX_SHADER_TYPE or TestCaseBase<API>::FRAGMENT_SHADER_TYPE). 7611 */ 7612 template <class API> 7613 void InteractionStorageBuffers3<API>::test_shader_compilation( 7614 typename TestCaseBase<API>::TestShaderType tested_shader_type) 7615 { 7616 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT }; 7617 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 7618 7619 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_FLOAT, VAR_TYPE_INT, VAR_TYPE_UINT, 7620 VAR_TYPE_DOUBLE }; 7621 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 7622 7623 const std::string invalid_size_declarations[] = { "[2][2][2][]", "[2][2][][2]", "[2][][2][2]", "[][2][2][2]", 7624 "[2][2][][]", "[2][][2][]", "[][2][2][]", "[2][][][2]", 7625 "[][2][][2]", "[][][2][2]", "[2][][][]", "[][2][][]", 7626 "[][][2][]", "[][][][2]", "[][][][]" }; 7627 const std::string array_initializers[] = { "float[2][2][2][2](float[2][2][2](float[2][2](float[2](1.0, 2.0)," 7628 "float[2](3.0, 4.0))," 7629 "float[2][2](float[2](5.0, 6.0)," 7630 "float[2](7.0, 8.0)))," 7631 "float[2][2][2](float[2][2](float[2](1.1, 2.1)," 7632 "float[2](3.1, 4.1))," 7633 "float[2][2](float[2](5.1, 6.1)," 7634 "float[2](7.1, 8.1))));\n", 7635 7636 "int[2][2][2][2](int[2][2][2](int[2][2](int[2]( 1, 2)," 7637 "int[2]( 3, 4))," 7638 "int[2][2](int[2]( 5, 6)," 7639 "int[2]( 7, 8)))," 7640 "int[2][2][2](int[2][2](int[2](11, 12)," 7641 "int[2](13, 14))," 7642 "int[2][2](int[2](15, 16)," 7643 "int[2](17, 18))));\n", 7644 7645 "uint[2][2][2][2](uint[2][2][2](uint[2][2](uint[2]( 1u, 2u)," 7646 "uint[2]( 3u, 4u))," 7647 "uint[2][2](uint[2]( 5u, 6u)," 7648 "uint[2]( 7u, 8u)))," 7649 "uint[2][2][2](uint[2][2](uint[2](11u, 12u)," 7650 "uint[2](13u, 14u))," 7651 "uint[2][2](uint[2](15u, 16u)," 7652 "uint[2](17u, 18u))));\n", 7653 7654 "double[2][2][2][2](double[2][2][2](double[2][2](double[2](1.0, 2.0)," 7655 "double[2](3.0, 4.0))," 7656 "double[2][2](double[2](5.0, 6.0)," 7657 "double[2](7.0, 8.0)))," 7658 "double[2][2][2](double[2][2](double[2](1.1, 2.1)," 7659 "double[2](3.1, 4.1))," 7660 "double[2][2](double[2](5.1, 6.1)," 7661 "double[2](7.1, 8.1))));\n" }; 7662 const glcts::test_var_type* var_types_set = var_types_set_es; 7663 size_t num_var_types = num_var_types_es; 7664 7665 if (API::USE_DOUBLE) 7666 { 7667 var_types_set = var_types_set_gl; 7668 num_var_types = num_var_types_gl; 7669 } 7670 7671 /* Iterate through float/ int/ uint types. 7672 * Case: without initializer. 7673 */ 7674 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 7675 { 7676 _supported_variable_types_map_const_iterator var_iterator = 7677 supported_variable_types_map.find(var_types_set[var_type_index]); 7678 7679 if (var_iterator != supported_variable_types_map.end()) 7680 { 7681 for (size_t invalid_size_declarations_index = 0; 7682 invalid_size_declarations_index < 7683 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]); 7684 invalid_size_declarations_index++) 7685 { 7686 std::string shader_source; 7687 7688 shader_source = "layout (std140) buffer MyStorage {\n"; 7689 shader_source += " " + var_iterator->second.type + 7690 invalid_size_declarations[invalid_size_declarations_index] + " my_variable;\n"; 7691 shader_source += "};\n\n"; 7692 shader_source += shader_start; 7693 7694 /* End main */ 7695 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 7696 7697 /* Execute test */ 7698 EXECUTE_SHADER_TEST(API::ALLOW_UNSIZED_DECLARATION && invalid_size_declarations_index == 3, 7699 tested_shader_type, shader_source); 7700 } /* for (int invalid_size_declarations_index = 0; ...) */ 7701 } 7702 else 7703 { 7704 TCU_FAIL("Type not found."); 7705 } 7706 } /* for (int var_type_index = 0; ...) */ 7707 7708 /* Iterate through float/ int/ uint types. 7709 * Case: with initializer. 7710 */ 7711 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 7712 { 7713 _supported_variable_types_map_const_iterator var_iterator = 7714 supported_variable_types_map.find(var_types_set[var_type_index]); 7715 7716 if (var_iterator != supported_variable_types_map.end()) 7717 { 7718 for (size_t invalid_size_declarations_index = 0; 7719 invalid_size_declarations_index < 7720 sizeof(invalid_size_declarations) / sizeof(invalid_size_declarations[0]); 7721 invalid_size_declarations_index++) 7722 { 7723 std::string shader_source; 7724 7725 shader_source = "layout (std140) buffer MyStorage {\n"; 7726 shader_source += " " + var_iterator->second.type + 7727 invalid_size_declarations[invalid_size_declarations_index] + 7728 " my_variable = " + array_initializers[var_type_index]; 7729 7730 var_iterator->second.type + invalid_size_declarations[invalid_size_declarations_index] + 7731 " my_variable = " + array_initializers[var_type_index]; 7732 shader_source += "};\n\n"; 7733 shader_source += shader_start; 7734 7735 /* End main */ 7736 DEFAULT_MAIN_ENDING(tested_shader_type, shader_source); 7737 7738 /* Execute test */ 7739 this->execute_negative_test(tested_shader_type, shader_source); 7740 } /* for (int invalid_size_declarations_index = 0; ...) */ 7741 } /* if var_type iterator found */ 7742 else 7743 { 7744 TCU_FAIL("Type not found."); 7745 } 7746 } /* for (int var_type_index = 0; ...) */ 7747 } 7748 7749 /* Generates the shader source code for the InteractionInterfaceArrays1 7750 * array test, and attempts to compile the test shader. 7751 * 7752 * @tparam API Tested API descriptor 7753 * 7754 * @param tested_shader_type The type of shader that is being tested. 7755 */ 7756 template <class API> 7757 void InteractionInterfaceArrays1<API>::test_shader_compilation( 7758 typename TestCaseBase<API>::TestShaderType tested_shader_type) 7759 { 7760 /* Shader source with invalid buffer (buffer cannot be of arrays of arrays type). */ 7761 const std::string invalid_buffer_shader_source = "layout(std140) buffer MyBuffer\n" 7762 "{\n" 7763 " float f;\n" 7764 " int i;\n" 7765 " uint ui;\n" 7766 "} myBuffers[2][2];\n\n" 7767 "void main()\n" 7768 "{\n"; 7769 7770 /* Verify that buffer arrays of arrays type is rejected. */ 7771 { 7772 std::string source = invalid_buffer_shader_source; 7773 7774 DEFAULT_MAIN_ENDING(tested_shader_type, source); 7775 7776 EXECUTE_SHADER_TEST(API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS, tested_shader_type, source); 7777 } 7778 } 7779 7780 /* Generates the shader source code for the InteractionInterfaceArrays2 7781 * array test, and attempts to compile the test shader. 7782 * 7783 * @tparam API Tested API descriptor 7784 * 7785 * @param input_shader_type The type of shader that is being tested. 7786 */ 7787 template <class API> 7788 void InteractionInterfaceArrays2<API>::test_shader_compilation( 7789 typename TestCaseBase<API>::TestShaderType input_shader_type) 7790 { 7791 /* Shader source with invalid input (input cannot be of arrays of arrays type). */ 7792 const std::string input_variable_shader_source[] = { "in float inout_variable", "[2][2];\n" 7793 "out float result", 7794 ";\n\n" 7795 "void main()\n" 7796 "{\n" 7797 " result", 7798 " = inout_variable", "[0][0];\n" }; 7799 /* Shader source with invalid output (output cannot be of arrays of arrays type). */ 7800 const std::string output_variable_shader_source[] = { "out float inout_variable", 7801 "[2][2];\n\n" 7802 "void main()\n" 7803 "{\n" 7804 " inout_variable", 7805 "[0][0] = 0.0;\n" 7806 " inout_variable", 7807 "[0][1] = 1.0;\n" 7808 " inout_variable", 7809 "[1][0] = 2.0;\n" 7810 " inout_variable", 7811 "[1][1] = 3.0;\n" }; 7812 7813 const typename TestCaseBase<API>::TestShaderType& output_shader_type = 7814 this->get_output_shader_type(input_shader_type); 7815 std::string input_source; 7816 std::string output_source; 7817 7818 this->prepare_sources(input_shader_type, output_shader_type, input_variable_shader_source, 7819 output_variable_shader_source, input_source, output_source); 7820 7821 /* Verify that INPUTs and OUTPUTs arrays of arrays type is rejected. */ 7822 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != input_shader_type) 7823 { 7824 if (API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS) 7825 { 7826 7827 if (API::USE_ALL_SHADER_STAGES) 7828 { 7829 const std::string& compute_shader_source = empty_string; 7830 const std::string& fragment_shader_source = 7831 this->prepare_fragment_shader(input_shader_type, input_source, output_source); 7832 const std::string& geometry_shader_source = 7833 this->prepare_geometry_shader(input_shader_type, input_source, output_source); 7834 const std::string& tess_ctrl_shader_source = 7835 this->prepare_tess_ctrl_shader_source(input_shader_type, input_source, output_source); 7836 const std::string& tess_eval_shader_source = 7837 this->prepare_tess_eval_shader_source(input_shader_type, input_source, output_source); 7838 const std::string& vertex_shader_source = 7839 this->prepare_vertex_shader(input_shader_type, input_source, output_source); 7840 7841 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 7842 geometry_shader_source, fragment_shader_source, compute_shader_source, true, 7843 false); 7844 } 7845 else 7846 { 7847 const std::string& fragment_shader_source = 7848 this->prepare_fragment_shader(input_shader_type, input_source, output_source); 7849 const std::string& vertex_shader_source = 7850 this->prepare_vertex_shader(input_shader_type, input_source, output_source); 7851 7852 this->execute_positive_test(vertex_shader_source, fragment_shader_source, true, false); 7853 } 7854 } 7855 else 7856 { 7857 this->execute_negative_test(input_shader_type, input_source); 7858 this->execute_negative_test(output_shader_type, output_source); 7859 } 7860 } 7861 } 7862 7863 /** Gets the shader type to test for the outputs 7864 * 7865 * @tparam API Tested API descriptor 7866 * 7867 * @param input_shader_type The type of input shader that is being tested 7868 **/ 7869 template <class API> 7870 const typename TestCaseBase<API>::TestShaderType InteractionInterfaceArrays2<API>::get_output_shader_type( 7871 const typename TestCaseBase<API>::TestShaderType& input_shader_type) 7872 { 7873 switch (input_shader_type) 7874 { 7875 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 7876 return TestCaseBase<API>::FRAGMENT_SHADER_TYPE; 7877 7878 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 7879 if (API::USE_ALL_SHADER_STAGES) 7880 { 7881 return TestCaseBase<API>::GEOMETRY_SHADER_TYPE; 7882 } 7883 else 7884 { 7885 return TestCaseBase<API>::VERTEX_SHADER_TYPE; 7886 } 7887 7888 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 7889 break; 7890 7891 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 7892 return TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE; 7893 7894 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 7895 return TestCaseBase<API>::VERTEX_SHADER_TYPE; 7896 7897 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 7898 return TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE; 7899 7900 default: 7901 TCU_FAIL("Unrecognized shader type."); 7902 break; 7903 } 7904 7905 return input_shader_type; 7906 } 7907 7908 /** Prepare fragment shader 7909 * 7910 * @tparam API Tested API descriptor 7911 * 7912 * @param input_shader_type The type of input shader that is being tested 7913 * @param input_source Shader in case we want to test inputs for this shader 7914 * @param output_source Shader in case we want to test outputs for this shader 7915 **/ 7916 template <class API> 7917 const std::string InteractionInterfaceArrays2<API>::prepare_fragment_shader( 7918 const typename TestCaseBase<API>::TestShaderType& input_shader_type, const std::string& input_source, 7919 const std::string& output_source) 7920 { 7921 switch (input_shader_type) 7922 { 7923 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 7924 return output_source; 7925 7926 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 7927 return input_source; 7928 7929 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 7930 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 7931 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 7932 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 7933 break; 7934 7935 default: 7936 TCU_FAIL("Unrecognized shader type."); 7937 break; 7938 } 7939 7940 return default_fragment_shader_source; 7941 } 7942 7943 /** Prepare geometry shader 7944 * 7945 * @tparam API Tested API descriptor 7946 * 7947 * @param input_shader_type The type of input shader that is being tested 7948 * @param input_source Shader in case we want to test inputs for this shader 7949 * @param output_source Shader in case we want to test outputs for this shader 7950 **/ 7951 template <class API> 7952 const std::string InteractionInterfaceArrays2<API>::prepare_geometry_shader( 7953 const typename TestCaseBase<API>::TestShaderType& input_shader_type, const std::string& input_source, 7954 const std::string& output_source) 7955 { 7956 switch (input_shader_type) 7957 { 7958 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 7959 if (API::USE_ALL_SHADER_STAGES) 7960 { 7961 return output_source; 7962 } 7963 break; 7964 7965 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 7966 return input_source; 7967 7968 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 7969 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 7970 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 7971 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 7972 break; 7973 7974 default: 7975 TCU_FAIL("Unrecognized shader type."); 7976 break; 7977 } 7978 7979 return default_geometry_shader_source; 7980 } 7981 7982 /** Prepare tessellation control shader 7983 * 7984 * @tparam API Tested API descriptor 7985 * 7986 * @param input_shader_type The type of input shader that is being tested 7987 * @param input_source Shader in case we want to test inputs for this shader 7988 * @param output_source Shader in case we want to test outputs for this shader 7989 **/ 7990 template <class API> 7991 const std::string InteractionInterfaceArrays2<API>::prepare_tess_ctrl_shader_source( 7992 const typename TestCaseBase<API>::TestShaderType& input_shader_type, const std::string& input_source, 7993 const std::string& output_source) 7994 { 7995 switch (input_shader_type) 7996 { 7997 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 7998 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 7999 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 8000 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8001 break; 8002 8003 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 8004 return input_source; 8005 8006 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8007 return output_source; 8008 8009 default: 8010 TCU_FAIL("Unrecognized shader type."); 8011 break; 8012 } 8013 8014 return default_tc_shader_source; 8015 } 8016 8017 /** Prepare tessellation evaluation shader 8018 * 8019 * @tparam API Tested API descriptor 8020 * 8021 * @param input_shader_type The type of input shader that is being tested 8022 * @param input_source Shader in case we want to test inputs for this shader 8023 * @param output_source Shader in case we want to test outputs for this shader 8024 **/ 8025 template <class API> 8026 const std::string InteractionInterfaceArrays2<API>::prepare_tess_eval_shader_source( 8027 const typename TestCaseBase<API>::TestShaderType& input_shader_type, const std::string& input_source, 8028 const std::string& output_source) 8029 { 8030 switch (input_shader_type) 8031 { 8032 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 8033 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 8034 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 8035 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 8036 break; 8037 8038 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8039 return output_source; 8040 8041 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8042 return input_source; 8043 8044 default: 8045 TCU_FAIL("Unrecognized shader type."); 8046 break; 8047 } 8048 8049 return default_te_shader_source; 8050 } 8051 8052 /** Prepare vertex shader 8053 * 8054 * @tparam API Tested API descriptor 8055 * 8056 * @param input_shader_type The type of input shader that is being tested 8057 * @param input_source Shader in case we want to test inputs for this shader 8058 * @param output_source Shader in case we want to test outputs for this shader 8059 **/ 8060 template <class API> 8061 const std::string InteractionInterfaceArrays2<API>::prepare_vertex_shader( 8062 const typename TestCaseBase<API>::TestShaderType& input_shader_type, const std::string& input_source, 8063 const std::string& output_source) 8064 { 8065 switch (input_shader_type) 8066 { 8067 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 8068 return input_source; 8069 8070 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 8071 if (!API::USE_ALL_SHADER_STAGES) 8072 { 8073 return output_source; 8074 } 8075 break; 8076 8077 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 8078 return output_source; 8079 8080 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 8081 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8082 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8083 break; 8084 8085 default: 8086 TCU_FAIL("Unrecognized shader type."); 8087 break; 8088 } 8089 8090 return default_vertex_shader_source; 8091 } 8092 8093 /** Prepare the inputs and outputs shaders 8094 * 8095 * @tparam API Tested API descriptor 8096 * 8097 * @param input_shader_type The type of input shader that is being tested 8098 * @param output_shader_type The type of output shader that is being tested 8099 * @param input_shader_source Snippet used to prepare the input shader 8100 * @param output_shader_source Snippet used to prepare the output shader 8101 * @param input_source Resulting input shader 8102 * @param output_source Resulting output shader 8103 **/ 8104 template <class API> 8105 void InteractionInterfaceArrays2<API>::prepare_sources( 8106 const typename TestCaseBase<API>::TestShaderType& input_shader_type, 8107 const typename TestCaseBase<API>::TestShaderType& output_shader_type, const std::string* input_shader_source, 8108 const std::string* output_shader_source, std::string& input_source, std::string& output_source) 8109 { 8110 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != input_shader_type) 8111 { 8112 input_source += input_shader_source[0]; 8113 output_source += output_shader_source[0]; 8114 8115 if ((TestCaseBase<API>::GEOMETRY_SHADER_TYPE == input_shader_type) || 8116 (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type) || 8117 (TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE == input_shader_type)) 8118 { 8119 input_source += "[]"; 8120 } 8121 8122 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type) 8123 { 8124 output_source += "[]"; 8125 } 8126 8127 input_source += input_shader_source[1]; 8128 output_source += output_shader_source[1]; 8129 8130 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type) 8131 { 8132 input_source += "[]"; 8133 } 8134 8135 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type) 8136 { 8137 output_source += "[gl_InvocationID]"; 8138 } 8139 8140 input_source += input_shader_source[2]; 8141 output_source += output_shader_source[2]; 8142 8143 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type) 8144 { 8145 input_source += "[gl_InvocationID]"; 8146 } 8147 8148 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type) 8149 { 8150 output_source += "[gl_InvocationID]"; 8151 } 8152 8153 input_source += input_shader_source[3]; 8154 output_source += output_shader_source[3]; 8155 8156 if ((TestCaseBase<API>::GEOMETRY_SHADER_TYPE == input_shader_type) || 8157 (TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE == input_shader_type)) 8158 { 8159 input_source += "[0]"; 8160 } 8161 8162 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == input_shader_type) 8163 { 8164 input_source += "[gl_InvocationID]"; 8165 } 8166 8167 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type) 8168 { 8169 output_source += "[gl_InvocationID]"; 8170 } 8171 8172 input_source += input_shader_source[4]; 8173 output_source += output_shader_source[4]; 8174 8175 if (TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE == output_shader_type) 8176 { 8177 output_source += "[gl_InvocationID]"; 8178 } 8179 8180 output_source += output_shader_source[5]; 8181 8182 DEFAULT_MAIN_ENDING(input_shader_type, input_source); 8183 DEFAULT_MAIN_ENDING(output_shader_type, output_source); 8184 } 8185 } 8186 8187 /* Generates the shader source code for the InteractionInterfaceArrays3 8188 * array test, and attempts to compile the test shader. 8189 * 8190 * @tparam API Tested API descriptor 8191 * 8192 * @param tested_shader_type The type of shader that is being tested. 8193 */ 8194 template <class API> 8195 void InteractionInterfaceArrays3<API>::test_shader_compilation( 8196 typename TestCaseBase<API>::TestShaderType tested_shader_type) 8197 { 8198 /* Shader source with invalid uniform block (uniform block cannot be of arrays of arrays type). */ 8199 const std::string invalid_uniform_block_shader_source = "layout(std140) uniform MyUniformBlock\n" 8200 "{\n" 8201 " float f;\n" 8202 " int i;\n" 8203 " uint ui;\n" 8204 "} myUniformBlocks[2][2];\n\n" 8205 "void main()\n" 8206 "{\n"; 8207 8208 /* Verify that uniform block arrays of arrays type is rejected. */ 8209 { 8210 std::string source = invalid_uniform_block_shader_source; 8211 8212 DEFAULT_MAIN_ENDING(tested_shader_type, source); 8213 8214 EXECUTE_SHADER_TEST(API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS, tested_shader_type, source); 8215 } 8216 } 8217 8218 /* Generates the shader source code for the InteractionInterfaceArrays4 8219 * array test, and attempts to compile the test shader. 8220 * 8221 * @tparam API Tested API descriptor 8222 * 8223 * @param input_shader_type The type of shader that is being tested. 8224 */ 8225 template <class API> 8226 void InteractionInterfaceArrays4<API>::test_shader_compilation( 8227 typename TestCaseBase<API>::TestShaderType input_shader_type) 8228 { 8229 /* Shader source with invalid input (input cannot be of arrays of arrays type). */ 8230 const std::string input_block_shader_source[] = { "in InOutBlock {\n" 8231 " float inout_variable;\n" 8232 "} inout_block", 8233 "[2][2];\n" 8234 "out float result", 8235 ";\n\n" 8236 "void main()\n" 8237 "{\n" 8238 " result", 8239 " = inout_block", "[0][0].inout_variable;\n" }; 8240 /* Shader source with invalid output (output cannot be of arrays of arrays type). */ 8241 const std::string output_block_shader_source[] = { "out InOutBlock {\n" 8242 " float inout_variable;\n" 8243 "} inout_block", 8244 "[2][2];\n" 8245 "\n" 8246 "void main()\n" 8247 "{\n" 8248 " inout_block", 8249 "[0][0].inout_variable = 0.0;\n" 8250 " inout_block", 8251 "[0][1].inout_variable = 1.0;\n" 8252 " inout_block", 8253 "[1][0].inout_variable = 2.0;\n" 8254 " inout_block", 8255 "[1][1].inout_variable = 3.0;\n" }; 8256 8257 const typename TestCaseBase<API>::TestShaderType& output_shader_type = 8258 this->get_output_shader_type(input_shader_type); 8259 std::string input_source; 8260 std::string output_source; 8261 8262 this->prepare_sources(input_shader_type, output_shader_type, input_block_shader_source, output_block_shader_source, 8263 input_source, output_source); 8264 8265 /* Verify that INPUTs and OUTPUTs arrays of arrays type is rejected. */ 8266 if ((TestCaseBase<API>::VERTEX_SHADER_TYPE != input_shader_type) && 8267 (TestCaseBase<API>::COMPUTE_SHADER_TYPE != input_shader_type)) 8268 { 8269 if (API::ALLOW_A_OF_A_ON_INTERFACE_BLOCKS && API::ALLOW_IN_OUT_INTERFACE_BLOCKS) 8270 { 8271 8272 if (API::USE_ALL_SHADER_STAGES) 8273 { 8274 const std::string& compute_shader_source = empty_string; 8275 const std::string& fragment_shader_source = 8276 this->prepare_fragment_shader(input_shader_type, input_source, output_source); 8277 const std::string& geometry_shader_source = 8278 this->prepare_geometry_shader(input_shader_type, input_source, output_source); 8279 const std::string& tess_ctrl_shader_source = 8280 this->prepare_tess_ctrl_shader_source(input_shader_type, input_source, output_source); 8281 const std::string& tess_eval_shader_source = 8282 this->prepare_tess_eval_shader_source(input_shader_type, input_source, output_source); 8283 const std::string& vertex_shader_source = 8284 this->prepare_vertex_shader(input_shader_type, input_source, output_source); 8285 8286 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 8287 geometry_shader_source, fragment_shader_source, compute_shader_source, true, 8288 false); 8289 } 8290 else 8291 { 8292 const std::string& fragment_shader_source = 8293 this->prepare_fragment_shader(input_shader_type, input_source, output_source); 8294 const std::string& vertex_shader_source = 8295 this->prepare_vertex_shader(input_shader_type, input_source, output_source); 8296 8297 this->execute_positive_test(vertex_shader_source, fragment_shader_source, true, false); 8298 } 8299 } 8300 else 8301 { 8302 this->execute_negative_test(input_shader_type, input_source); 8303 this->execute_negative_test(output_shader_type, output_source); 8304 } 8305 } 8306 } 8307 8308 /** Calulate smallest denominator for values over 1 8309 * 8310 * @param value Value in question 8311 * 8312 * @return Smallest denominator 8313 **/ 8314 size_t findSmallestDenominator(const size_t value) 8315 { 8316 /* Skip 0 and 1 */ 8317 for (size_t i = 2; i < value; ++i) 8318 { 8319 if (0 == value % i) 8320 { 8321 return i; 8322 } 8323 } 8324 8325 return value; 8326 } 8327 8328 /** Check if left is bigger than right 8329 * 8330 * @tparam T Type of values 8331 8332 * @param l Left value 8333 * @param r Right value 8334 * 8335 * @return true if l > r, false otherwise 8336 **/ 8337 template <class T> 8338 bool more(const T& l, const T& r) 8339 { 8340 return l > r; 8341 } 8342 8343 /** Prepare dimensions of array with given number of entries 8344 * 8345 * @tparam API Tested API descriptor 8346 * 8347 * @param n_entries Number of entries 8348 * @param dimensions Storage for dimesnions 8349 **/ 8350 template <class API> 8351 void prepareDimensions(size_t n_entries, std::vector<size_t>& dimensions) 8352 { 8353 if (dimensions.empty()) 8354 return; 8355 8356 const size_t last = dimensions.size() - 1; 8357 8358 /* Calculate */ 8359 for (size_t i = 0; i < last; ++i) 8360 { 8361 const size_t denom = findSmallestDenominator(n_entries); 8362 8363 n_entries /= denom; 8364 8365 dimensions[i] = denom; 8366 } 8367 8368 dimensions[last] = n_entries; 8369 8370 /* Sort */ 8371 std::sort(dimensions.begin(), dimensions.end(), more<size_t>); 8372 } 8373 8374 /* Generates the shader source code for the AtomicDeclarationTest 8375 * and attempts to compile each shader 8376 * 8377 * @tparam API Tested API descriptor 8378 * 8379 * @param tested_shader_type The type of shader that is being tested 8380 */ 8381 template <class API> 8382 void AtomicDeclarationTest<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 8383 { 8384 static const char* indent_step = " "; 8385 static const char* uniform_atomic_uint = "layout(binding = 0) uniform atomic_uint"; 8386 8387 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 8388 8389 std::string comment; 8390 std::vector<size_t> dimensions; 8391 std::string indent; 8392 std::string indexing; 8393 std::string invalid_definition = uniform_atomic_uint; 8394 std::string invalid_iteration; 8395 std::string invalid_shader_source; 8396 std::string loop_end; 8397 glw::GLint max_atomics = 0; 8398 glw::GLenum pname = 0; 8399 std::string valid_shader_source; 8400 std::string valid_definition = uniform_atomic_uint; 8401 std::string valid_iteration; 8402 8403 /* Select pname of max for stage */ 8404 switch (tested_shader_type) 8405 { 8406 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 8407 pname = GL_MAX_COMPUTE_ATOMIC_COUNTERS; 8408 break; 8409 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 8410 pname = GL_MAX_FRAGMENT_ATOMIC_COUNTERS; 8411 break; 8412 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8413 pname = GL_MAX_GEOMETRY_ATOMIC_COUNTERS; 8414 break; 8415 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 8416 pname = GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS; 8417 break; 8418 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8419 pname = GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS; 8420 break; 8421 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 8422 pname = GL_MAX_VERTEX_ATOMIC_COUNTERS; 8423 break; 8424 default: 8425 TCU_FAIL("Invalid enum"); 8426 break; 8427 } 8428 8429 /* Get maximum */ 8430 gl.getIntegerv(pname, &max_atomics); 8431 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 8432 8433 if (0 == max_atomics) 8434 { 8435 /* Not supported - skip */ 8436 return; 8437 } 8438 else 8439 { 8440 dimensions.resize(API::MAX_ARRAY_DIMENSIONS); 8441 prepareDimensions<API>(max_atomics, dimensions); 8442 } 8443 8444 /* Prepare parts of shader */ 8445 for (size_t i = API::MAX_ARRAY_DIMENSIONS; i != 0; --i) 8446 { 8447 char it[16]; 8448 char max[16]; 8449 8450 indent += indent_step; 8451 8452 loop_end.insert(0, "}\n"); 8453 loop_end.insert(0, indent); 8454 8455 sprintf(it, "i%u", (unsigned int)(API::MAX_ARRAY_DIMENSIONS - i)); 8456 8457 indexing += "["; 8458 indexing += it; 8459 indexing += "]"; 8460 8461 sprintf(max, "%u", (unsigned int)(dimensions[i - 1])); 8462 8463 valid_definition += "["; 8464 valid_definition += max; 8465 valid_definition += "]"; 8466 8467 valid_iteration += indent; 8468 valid_iteration += "for (uint "; 8469 valid_iteration += it; 8470 valid_iteration += " = 0; "; 8471 valid_iteration += it; 8472 valid_iteration += " < "; 8473 valid_iteration += max; 8474 valid_iteration += "; ++"; 8475 valid_iteration += it; 8476 valid_iteration += ")\n"; 8477 valid_iteration += indent; 8478 valid_iteration += "{\n"; 8479 8480 if (1 == i) 8481 { 8482 sprintf(max, "%u", (unsigned int)(dimensions[i - 1] + 1)); 8483 } 8484 invalid_definition += "["; 8485 invalid_definition += max; 8486 invalid_definition += "]"; 8487 8488 invalid_iteration += indent; 8489 invalid_iteration += "for (uint "; 8490 invalid_iteration += it; 8491 invalid_iteration += " = 0; "; 8492 invalid_iteration += it; 8493 invalid_iteration += " < "; 8494 invalid_iteration += max; 8495 invalid_iteration += "; ++"; 8496 invalid_iteration += it; 8497 invalid_iteration += ")\n"; 8498 invalid_iteration += indent; 8499 invalid_iteration += "{\n"; 8500 } 8501 8502 { 8503 char max[16]; 8504 8505 sprintf(max, "%u", (unsigned int)(max_atomics)); 8506 comment += "/* MAX_*_ATOMIC_COUNTERS = "; 8507 comment += max; 8508 comment += " */\n"; 8509 } 8510 8511 /* Prepare invalid source */ 8512 invalid_shader_source += comment; 8513 invalid_shader_source += invalid_definition; 8514 invalid_shader_source += " a;\n\nvoid main()\n{\n"; 8515 invalid_shader_source += invalid_iteration; 8516 invalid_shader_source += indent; 8517 invalid_shader_source += indent_step; 8518 invalid_shader_source += "atomicCounterIncrement( a"; 8519 invalid_shader_source += indexing; 8520 invalid_shader_source += " );\n"; 8521 invalid_shader_source += loop_end; 8522 8523 /* Prepare valid source */ 8524 valid_shader_source += comment; 8525 valid_shader_source += valid_definition; 8526 valid_shader_source += " a;\n\nvoid main()\n{\n"; 8527 valid_shader_source += valid_iteration; 8528 valid_shader_source += indent; 8529 valid_shader_source += indent_step; 8530 valid_shader_source += "atomicCounterIncrement( a"; 8531 valid_shader_source += indexing; 8532 valid_shader_source += " );\n"; 8533 valid_shader_source += loop_end; 8534 8535 /* End main */ 8536 DEFAULT_MAIN_ENDING(tested_shader_type, invalid_shader_source); 8537 DEFAULT_MAIN_ENDING(tested_shader_type, valid_shader_source); 8538 8539 /* Execute test */ 8540 EXECUTE_POSITIVE_TEST(tested_shader_type, valid_shader_source, true, false); 8541 8542 /* Expect build failure for invalid shader source */ 8543 { 8544 bool negative_build_test_result = false; 8545 8546 try 8547 { 8548 EXECUTE_POSITIVE_TEST(tested_shader_type, invalid_shader_source, true, false); 8549 } 8550 catch (...) 8551 { 8552 negative_build_test_result = true; 8553 } 8554 8555 if (false == negative_build_test_result) 8556 { 8557 TCU_FAIL("It was expected that build process will fail"); 8558 } 8559 } 8560 } 8561 8562 /* Generates the shader source code for the AtomicUsageTest 8563 * and attempts to compile each shader 8564 * 8565 * @tparam API Tested API descriptor 8566 * 8567 * @param tested_shader_type The type of shader that is being tested 8568 */ 8569 template <class API> 8570 void AtomicUsageTest<API>::test_shader_compilation(typename TestCaseBase<API>::TestShaderType tested_shader_type) 8571 { 8572 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 8573 8574 glw::GLint max_atomics = 0; 8575 glw::GLint max_bindings = 0; 8576 glw::GLint max_size = 0; 8577 glw::GLenum pname = 0; 8578 8579 /* Select pname of max for stage */ 8580 switch (tested_shader_type) 8581 { 8582 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 8583 pname = GL_MAX_COMPUTE_ATOMIC_COUNTERS; 8584 break; 8585 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 8586 pname = GL_MAX_FRAGMENT_ATOMIC_COUNTERS; 8587 break; 8588 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8589 pname = GL_MAX_GEOMETRY_ATOMIC_COUNTERS; 8590 break; 8591 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 8592 pname = GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS; 8593 break; 8594 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8595 pname = GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS; 8596 break; 8597 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 8598 pname = GL_MAX_VERTEX_ATOMIC_COUNTERS; 8599 break; 8600 default: 8601 TCU_FAIL("Invalid enum"); 8602 break; 8603 } 8604 8605 /* Get limits */ 8606 gl.getIntegerv(pname, &max_atomics); 8607 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 8608 8609 gl.getIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &max_bindings); 8610 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 8611 8612 gl.getIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE, &max_size); 8613 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 8614 8615 if (0 == max_atomics) 8616 { 8617 /* Not supported - skip */ 8618 return; 8619 } 8620 8621 const glw::GLuint last_binding = (glw::GLuint)max_bindings - 1; 8622 const glw::GLuint offset = (glw::GLuint)max_size / 2; 8623 glw::GLuint n_entries = 8624 std::min((glw::GLuint)(max_size - offset) / (glw::GLuint)sizeof(glw::GLuint), (glw::GLuint)max_atomics); 8625 8626 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type) 8627 { 8628 glw::GLint max_uniform_locations = 0; 8629 8630 gl.getIntegerv(GL_MAX_UNIFORM_LOCATIONS, &max_uniform_locations); 8631 GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); 8632 8633 max_atomics = std::min(max_atomics, (max_uniform_locations - 1)); 8634 n_entries = (glw::GLuint)std::min((glw::GLint)n_entries, (max_uniform_locations - 1)); 8635 } 8636 8637 execute(tested_shader_type, last_binding, 0 /* offset */, max_atomics); 8638 execute(tested_shader_type, last_binding, offset, n_entries); 8639 } 8640 8641 /* Generates the shader source code for the AtomicUsageTest 8642 * and attempts to compile each shader 8643 * 8644 * @tparam API Tested API descriptor 8645 * 8646 * @param tested_shader_type The type of shader that is being tested 8647 * @param binding Binding index 8648 * @param offset Offset of data 8649 * @param n_entries Number of entries in array 8650 */ 8651 template <class API> 8652 void AtomicUsageTest<API>::execute(typename TestCaseBase<API>::TestShaderType tested_shader_type, glw::GLuint binding, 8653 glw::GLuint offset, glw::GLuint n_entries) 8654 { 8655 static const char* indent_step = " "; 8656 static const char* layout_binding = "layout(binding = "; 8657 static const char* layout_offset = ", offset = "; 8658 static const char* uniform_atomic_uint = ") uniform atomic_uint"; 8659 8660 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 8661 8662 std::string comment; 8663 std::vector<size_t> dimensions; 8664 std::string indent; 8665 std::string indexing; 8666 std::string loop_end; 8667 std::string result; 8668 std::string valid_shader_source; 8669 std::string valid_definition = layout_binding; 8670 std::string valid_iteration; 8671 std::string varying_definition; 8672 8673 dimensions.resize(API::MAX_ARRAY_DIMENSIONS); 8674 prepareDimensions<API>(n_entries, dimensions); 8675 8676 /* Prepare parts of shader */ 8677 8678 /* Append binding */ 8679 { 8680 char buffer[16]; 8681 sprintf(buffer, "%u", static_cast<unsigned int>(binding)); 8682 valid_definition += buffer; 8683 valid_definition += layout_offset; 8684 sprintf(buffer, "%u", static_cast<unsigned int>(offset)); 8685 valid_definition += buffer; 8686 valid_definition += uniform_atomic_uint; 8687 } 8688 8689 for (size_t i = API::MAX_ARRAY_DIMENSIONS; i != 0; --i) 8690 { 8691 char it[16]; 8692 char max[16]; 8693 8694 indent += indent_step; 8695 8696 loop_end.insert(0, "}\n"); 8697 loop_end.insert(0, indent); 8698 8699 sprintf(it, "i%u", (unsigned int)(API::MAX_ARRAY_DIMENSIONS - i)); 8700 8701 indexing += "["; 8702 indexing += it; 8703 indexing += "]"; 8704 8705 sprintf(max, "%u", (unsigned int)(dimensions[i - 1])); 8706 valid_definition += "["; 8707 valid_definition += max; 8708 valid_definition += "]"; 8709 8710 valid_iteration += indent; 8711 valid_iteration += "for (uint "; 8712 valid_iteration += it; 8713 valid_iteration += " = 0; "; 8714 valid_iteration += it; 8715 valid_iteration += " < "; 8716 valid_iteration += max; 8717 valid_iteration += "; ++"; 8718 valid_iteration += it; 8719 valid_iteration += ")\n"; 8720 valid_iteration += indent; 8721 valid_iteration += "{\n"; 8722 } 8723 8724 { 8725 char max[16]; 8726 8727 sprintf(max, "%u", (unsigned int)(n_entries)); 8728 comment += "/* Number of atomic counters = "; 8729 comment += max; 8730 comment += " */\n"; 8731 } 8732 8733 /* Select varyings and result */ 8734 switch (tested_shader_type) 8735 { 8736 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 8737 result = " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n"; 8738 varying_definition = "writeonly uniform image2D uni_image;\n" 8739 "\n"; 8740 break; 8741 8742 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 8743 result = " color = vec4(result);\n"; 8744 varying_definition = "out vec4 color;\n" 8745 "\n"; 8746 break; 8747 8748 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8749 result = " gl_Position = vec4(-1, -1, 0, 1);\n" 8750 " fs_result = result;\n" 8751 " EmitVertex();\n" 8752 " gl_Position = vec4(-1, 1, 0, 1);\n" 8753 " fs_result = result;\n" 8754 " EmitVertex();\n" 8755 " gl_Position = vec4(1, -1, 0, 1);\n" 8756 " fs_result = result;\n" 8757 " EmitVertex();\n" 8758 " gl_Position = vec4(1, 1, 0, 1);\n" 8759 " fs_result = result;\n" 8760 " EmitVertex();\n"; 8761 varying_definition = "out float fs_result;\n" 8762 "\n"; 8763 break; 8764 8765 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 8766 result = " tcs_result[gl_InvocationID] = result;\n" 8767 "\n" 8768 " gl_TessLevelOuter[0] = 1.0;\n" 8769 " gl_TessLevelOuter[1] = 1.0;\n" 8770 " gl_TessLevelOuter[2] = 1.0;\n" 8771 " gl_TessLevelOuter[3] = 1.0;\n" 8772 " gl_TessLevelInner[0] = 1.0;\n" 8773 " gl_TessLevelInner[1] = 1.0;\n"; 8774 varying_definition = "out float tcs_result[];\n" 8775 "\n"; 8776 break; 8777 8778 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8779 result = " fs_result = result;\n"; 8780 varying_definition = "out float fs_result;\n" 8781 "\n"; 8782 break; 8783 8784 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 8785 result = " fs_result = result;\n"; 8786 varying_definition = "out float fs_result;\n" 8787 "\n"; 8788 break; 8789 8790 default: 8791 TCU_FAIL("Invalid enum"); 8792 break; 8793 }; 8794 8795 /* Prepare valid source */ 8796 valid_shader_source += varying_definition; 8797 valid_shader_source += comment; 8798 valid_shader_source += valid_definition; 8799 valid_shader_source += " a;\n\nvoid main()\n{\n uint sum = 0u;\n"; 8800 valid_shader_source += valid_iteration; 8801 valid_shader_source += indent; 8802 valid_shader_source += indent_step; 8803 valid_shader_source += "sum += atomicCounterIncrement( a"; 8804 valid_shader_source += indexing; 8805 valid_shader_source += " );\n"; 8806 valid_shader_source += loop_end; 8807 valid_shader_source += "\n" 8808 " float result = 0.0;\n" 8809 "\n" 8810 " if (16u < sum)\n" 8811 " {\n" 8812 " result = 1.0;\n" 8813 " }\n"; 8814 valid_shader_source += result; 8815 valid_shader_source += shader_end; 8816 8817 /* Build program */ 8818 { 8819 const std::string* cs = &empty_string; 8820 const std::string* vs = &default_vertex_shader_source; 8821 const std::string* tcs = &empty_string; 8822 const std::string* tes = &empty_string; 8823 const std::string* gs = &empty_string; 8824 const std::string* fs = &pass_fragment_shader_source; 8825 8826 switch (tested_shader_type) 8827 { 8828 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 8829 cs = &valid_shader_source; 8830 vs = &empty_string; 8831 fs = &empty_string; 8832 break; 8833 8834 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 8835 fs = &valid_shader_source; 8836 break; 8837 8838 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8839 gs = &valid_shader_source; 8840 break; 8841 8842 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 8843 tcs = &valid_shader_source; 8844 tes = &pass_te_shader_source; 8845 break; 8846 8847 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8848 tcs = &default_tc_shader_source; 8849 tes = &valid_shader_source; 8850 break; 8851 8852 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 8853 vs = &valid_shader_source; 8854 break; 8855 8856 default: 8857 TCU_FAIL("Invalid enum"); 8858 break; 8859 }; 8860 8861 if (API::USE_ALL_SHADER_STAGES) 8862 { 8863 this->execute_positive_test(*vs, *tcs, *tes, *gs, *fs, *cs, false, false); 8864 } 8865 else 8866 { 8867 this->execute_positive_test(*vs, *fs, false, false); 8868 } 8869 } 8870 8871 gl.useProgram(this->program_object_id); 8872 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 8873 8874 /* Prepare buffer */ 8875 glw::GLuint buffer_object_id = 0; 8876 std::vector<glw::GLuint> buffer_data; 8877 const size_t start_pos = offset / 4; 8878 const size_t last_pos = start_pos + n_entries; 8879 const size_t buffer_data_size = last_pos * sizeof(glw::GLuint); 8880 8881 gl.genBuffers(1, &buffer_object_id); 8882 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() failed."); 8883 8884 gl.bindBuffer(GL_ATOMIC_COUNTER_BUFFER, buffer_object_id); 8885 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() failed."); 8886 8887 buffer_data.resize(start_pos + n_entries); 8888 for (size_t i = 0; i < n_entries; ++i) 8889 { 8890 buffer_data[start_pos + i] = (glw::GLuint)i; 8891 } 8892 8893 gl.bufferData(GL_ATOMIC_COUNTER_BUFFER, buffer_data_size, &buffer_data[0], GL_STATIC_DRAW); 8894 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() failed."); 8895 8896 gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, binding, buffer_object_id); 8897 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() failed."); 8898 8899 /* Run program */ 8900 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE != tested_shader_type) 8901 { 8902 glw::GLuint framebuffer_object_id = 0; 8903 glw::GLuint texture_object_id = 0; 8904 glw::GLuint vao_id = 0; 8905 8906 gl.genTextures(1, &texture_object_id); 8907 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed."); 8908 8909 gl.bindTexture(GL_TEXTURE_2D, texture_object_id); 8910 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed."); 8911 8912 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1); 8913 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed."); 8914 8915 gl.genFramebuffers(1, &framebuffer_object_id); 8916 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed."); 8917 8918 gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id); 8919 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed."); 8920 8921 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0); 8922 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed."); 8923 8924 gl.viewport(0, 0, 1, 1); 8925 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed."); 8926 8927 gl.genVertexArrays(1, &vao_id); 8928 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 8929 8930 gl.bindVertexArray(vao_id); 8931 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 8932 8933 switch (tested_shader_type) 8934 { 8935 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 8936 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 8937 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 8938 gl.drawArrays(GL_POINTS, 0, 1); 8939 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 8940 break; 8941 8942 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 8943 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 8944 /* Tesselation patch set up */ 8945 gl.patchParameteri(GL_PATCH_VERTICES, 1); 8946 GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); 8947 8948 gl.drawArrays(GL_PATCHES, 0, 1); 8949 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 8950 break; 8951 8952 default: 8953 TCU_FAIL("Invalid enum"); 8954 break; 8955 } 8956 8957 gl.memoryBarrier(GL_ALL_BARRIER_BITS); 8958 GLU_EXPECT_NO_ERROR(gl.getError(), "MemoryBarrier."); 8959 8960 gl.bindTexture(GL_TEXTURE_2D, 0); 8961 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 8962 gl.bindVertexArray(0); 8963 gl.deleteTextures(1, &texture_object_id); 8964 gl.deleteFramebuffers(1, &framebuffer_object_id); 8965 gl.deleteVertexArrays(1, &vao_id); 8966 GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects."); 8967 } 8968 else 8969 { 8970 gl.dispatchCompute(1, 1, 1); 8971 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 8972 8973 gl.memoryBarrier(GL_ALL_BARRIER_BITS); 8974 GLU_EXPECT_NO_ERROR(gl.getError(), "MemoryBarrier."); 8975 } 8976 8977 /* Verify results */ 8978 bool test_result = true; 8979 8980 const glw::GLuint* results = 8981 (glw::GLuint*)gl.mapBufferRange(GL_ATOMIC_COUNTER_BUFFER, 0 /* offset */, buffer_data_size, GL_MAP_READ_BIT); 8982 GLU_EXPECT_NO_ERROR(gl.getError(), "MapBufferRange"); 8983 8984 /* Anything before start position should be 0 */ 8985 for (size_t i = 0; i < start_pos; ++i) 8986 { 8987 if (0 != results[i]) 8988 { 8989 test_result = false; 8990 break; 8991 } 8992 } 8993 8994 /* Anything from start_pos should be incremented by 1 */ 8995 int diff = 0; 8996 for (size_t i = 0; i < n_entries; ++i) 8997 { 8998 /* Tesselation evaluation can be called several times 8999 In here, check the increment is consistent over all results. 9000 */ 9001 if (tested_shader_type == TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE) 9002 { 9003 if (i == 0) 9004 { 9005 diff = static_cast<int>(results[i + start_pos]) - static_cast<int>(i); 9006 if (diff <= 0) 9007 { 9008 test_result = false; 9009 break; 9010 } 9011 } 9012 else if ((static_cast<int>(results[i + start_pos]) - static_cast<int>(i)) != diff) 9013 { 9014 test_result = false; 9015 break; 9016 } 9017 } 9018 else 9019 { 9020 if (i + 1 != results[i + start_pos]) 9021 { 9022 test_result = false; 9023 break; 9024 } 9025 } 9026 } 9027 9028 gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER); 9029 GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); 9030 9031 /* Deallocate any resources used. */ 9032 gl.deleteBuffers(1, &buffer_object_id); 9033 this->delete_objects(); 9034 9035 if (false == test_result) 9036 { 9037 TCU_FAIL("Invalid results."); 9038 } 9039 } 9040 9041 /* Generates the shader source code for the SubroutineFunctionCalls1 9042 * array tests, attempts to build and execute test program 9043 * 9044 * @tparam API Tested API descriptor 9045 * 9046 * @param tested_shader_type The type of shader that is being tested 9047 */ 9048 template <class API> 9049 void SubroutineFunctionCalls1<API>::test_shader_compilation( 9050 typename TestCaseBase<API>::TestShaderType tested_shader_type) 9051 { 9052 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 9053 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 9054 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 9055 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 9056 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 9057 9058 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 9059 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 9060 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 9061 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 9062 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 9063 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 9064 9065 const std::string iteration_loop_end = " }\n" 9066 " }\n" 9067 " }\n" 9068 " }\n" 9069 " }\n" 9070 " }\n" 9071 " }\n" 9072 " }\n"; 9073 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 9074 " {\n" 9075 " for (uint b = 0u; b < 2u; b++)\n" 9076 " {\n" 9077 " for (uint c = 0u; c < 2u; c++)\n" 9078 " {\n" 9079 " for (uint d = 0u; d < 2u; d++)\n" 9080 " {\n" 9081 " for (uint e = 0u; e < 2u; e++)\n" 9082 " {\n" 9083 " for (uint f = 0u; f < 2u; f++)\n" 9084 " {\n" 9085 " for (uint g = 0u; g < 2u; g++)\n" 9086 " {\n" 9087 " for (uint h = 0u; h < 2u; h++)\n" 9088 " {\n"; 9089 const glcts::test_var_type* var_types_set = var_types_set_es; 9090 size_t num_var_types = num_var_types_es; 9091 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 9092 9093 if (API::USE_DOUBLE) 9094 { 9095 var_types_set = var_types_set_gl; 9096 num_var_types = num_var_types_gl; 9097 } 9098 9099 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 9100 { 9101 _supported_variable_types_map_const_iterator var_iterator = 9102 supported_variable_types_map.find(var_types_set[var_type_index]); 9103 9104 if (var_iterator != supported_variable_types_map.end()) 9105 { 9106 std::string iterator_declaration = " " + var_iterator->second.iterator_type + 9107 " iterator = " + var_iterator->second.iterator_initialization + ";\n"; 9108 9109 std::string function_definition; 9110 std::string function_use; 9111 std::string verification; 9112 9113 function_definition += "// Subroutine types\n" 9114 "subroutine void out_routine_type(out "; 9115 function_definition += var_iterator->second.type; 9116 function_definition += " output_array[2][2][2][2][2][2][2][2]);\n\n" 9117 "// Subroutine definitions\n" 9118 "subroutine(out_routine_type) void original_routine(out "; 9119 function_definition += var_iterator->second.type; 9120 function_definition += " output_array[2][2][2][2][2][2][2][2]) {\n"; 9121 function_definition += iterator_declaration; 9122 function_definition += iteration_loop_start; 9123 function_definition += " output_array[a][b][c][d][e][f][g][h] = " + 9124 var_iterator->second.variable_type_initializer1 + ";\n"; 9125 function_definition += 9126 " iterator += " + var_iterator->second.iterator_type + "(1);\n"; 9127 function_definition += iteration_loop_end; 9128 function_definition += "}\n\n"; 9129 function_definition += "subroutine(out_routine_type) void new_routine(out "; 9130 function_definition += var_iterator->second.type; 9131 function_definition += " output_array[2][2][2][2][2][2][2][2]) {\n"; 9132 function_definition += iterator_declaration; 9133 function_definition += iteration_loop_start; 9134 function_definition += " output_array[a][b][c][d][e][f][g][h] = " + 9135 var_iterator->second.variable_type_initializer1 + ";\n"; 9136 function_definition += 9137 " iterator -= " + var_iterator->second.iterator_type + "(1);\n"; 9138 function_definition += iteration_loop_end; 9139 function_definition += "}\n\n" 9140 "// Subroutine uniform\n" 9141 "subroutine uniform out_routine_type routine;\n"; 9142 9143 function_use = " " + var_iterator->second.type + " my_array[2][2][2][2][2][2][2][2];\n"; 9144 function_use += " routine(my_array);"; 9145 9146 verification = iterator_declaration; 9147 verification += " float result = 1.0;\n"; 9148 verification += iteration_loop_start; 9149 verification += " if (my_array[a][b][c][d][e][f][g][h] " + 9150 var_iterator->second.specific_element + 9151 " != iterator)\n" 9152 " {\n" 9153 " result = 0.0;\n" 9154 " }\n" 9155 " iterator += " + 9156 var_iterator->second.iterator_type + "(1);\n"; 9157 verification += iteration_loop_end; 9158 9159 if (false == test_compute) 9160 { 9161 execute_draw_test(tested_shader_type, function_definition, function_use, verification, false, true); 9162 execute_draw_test(tested_shader_type, function_definition, function_use, verification, true, false); 9163 } 9164 else 9165 { 9166 execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false, true); 9167 execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true, false); 9168 } 9169 9170 /* Deallocate any resources used. */ 9171 this->delete_objects(); 9172 } /* if var_type iterator found */ 9173 else 9174 { 9175 TCU_FAIL("Type not found."); 9176 } 9177 } /* for (int var_type_index = 0; ...) */ 9178 } 9179 9180 /** Executes test for compute program 9181 * 9182 * @tparam API Tested API descriptor 9183 * 9184 * @param tested_shader_type The type of shader that is being tested 9185 * @param function_definition Definition used to prepare shader 9186 * @param function_use Use of definition 9187 * @param verification Result verification 9188 * @param use_original Selects if "original_routine" - true or "new_routine" is choosen 9189 * @param expect_invalid_result Does test expects invalid results 9190 **/ 9191 template <class API> 9192 void SubroutineFunctionCalls1<API>::execute_dispatch_test(typename TestCaseBase<API>::TestShaderType tested_shader_type, 9193 const std::string& function_definition, 9194 const std::string& function_use, 9195 const std::string& verification, bool use_original, 9196 bool expect_invalid_result) 9197 { 9198 const std::string& compute_shader_source = 9199 prepare_compute_shader(tested_shader_type, function_definition, function_use, verification); 9200 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 9201 9202 this->execute_positive_test(empty_string, empty_string, empty_string, empty_string, empty_string, 9203 compute_shader_source, false, false); 9204 9205 /* We are now ready to verify whether the returned size is correct. */ 9206 unsigned char buffer[4] = { 0 }; 9207 glw::GLuint framebuffer_object_id = 0; 9208 glw::GLint location = -1; 9209 glw::GLuint routine_index = -1; 9210 glw::GLuint routine_location = -1; 9211 const glw::GLchar* routine_name = "original_routine"; 9212 const glw::GLenum shader_type = GL_COMPUTE_SHADER; 9213 glw::GLuint texture_object_id = 0; 9214 9215 if (false == use_original) 9216 { 9217 routine_name = "new_routine"; 9218 } 9219 9220 gl.useProgram(this->program_object_id); 9221 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 9222 9223 /* Select subroutine */ 9224 routine_index = gl.getSubroutineIndex(this->program_object_id, shader_type, routine_name); 9225 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() failed."); 9226 9227 routine_location = gl.getSubroutineUniformLocation(this->program_object_id, shader_type, "routine"); 9228 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() failed."); 9229 9230 if (0 != routine_location) 9231 { 9232 TCU_FAIL("Subroutine location is invalid"); 9233 } 9234 9235 gl.uniformSubroutinesuiv(shader_type, 1, &routine_index); 9236 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() failed."); 9237 9238 /* Prepare texture */ 9239 gl.genTextures(1, &texture_object_id); 9240 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed."); 9241 9242 gl.bindTexture(GL_TEXTURE_2D, texture_object_id); 9243 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed."); 9244 9245 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1); 9246 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed."); 9247 9248 gl.bindImageTexture(0 /* image unit */, texture_object_id, 0 /* level */, GL_FALSE /* layered */, 0 /* layer */, 9249 GL_WRITE_ONLY, GL_RGBA8); 9250 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() failed."); 9251 9252 location = gl.getUniformLocation(this->program_object_id, "uni_image"); 9253 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation() failed."); 9254 9255 if (-1 == location) 9256 { 9257 TCU_FAIL("Uniform is inactive"); 9258 } 9259 9260 gl.uniform1i(location, 0 /* image unit */); 9261 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i() failed."); 9262 9263 /* Execute */ 9264 gl.dispatchCompute(1, 1, 1); 9265 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 9266 9267 /* Verify */ 9268 gl.genFramebuffers(1, &framebuffer_object_id); 9269 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed."); 9270 9271 gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id); 9272 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed."); 9273 9274 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0); 9275 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed."); 9276 9277 gl.viewport(0, 0, 1, 1); 9278 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed."); 9279 9280 gl.readBuffer(GL_COLOR_ATTACHMENT0); 9281 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed."); 9282 9283 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); 9284 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed."); 9285 9286 if ((buffer[0] != 255) != expect_invalid_result) 9287 { 9288 TCU_FAIL("Invalid result was returned."); 9289 } 9290 9291 /* Delete generated objects. */ 9292 gl.deleteTextures(1, &texture_object_id); 9293 gl.deleteFramebuffers(1, &framebuffer_object_id); 9294 GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects."); 9295 } 9296 9297 /** Executes test for draw program 9298 * 9299 * @tparam API Tested API descriptor 9300 * 9301 * @param tested_shader_type The type of shader that is being tested 9302 * @param function_definition Definition used to prepare shader 9303 * @param function_use Use of definition 9304 * @param verification Result verification 9305 * @param use_original Selects if "original_routine" - true or "new_routine" is choosen 9306 * @param expect_invalid_result Does test expects invalid results 9307 **/ 9308 template <class API> 9309 void SubroutineFunctionCalls1<API>::execute_draw_test(typename TestCaseBase<API>::TestShaderType tested_shader_type, 9310 const std::string& function_definition, 9311 const std::string& function_use, const std::string& verification, 9312 bool use_original, bool expect_invalid_result) 9313 { 9314 const glw::Functions& gl = this->context_id.getRenderContext().getFunctions(); 9315 9316 if (API::USE_ALL_SHADER_STAGES) 9317 { 9318 const std::string& compute_shader_source = empty_string; 9319 const std::string& fragment_shader_source = 9320 this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification); 9321 const std::string& geometry_shader_source = 9322 this->prepare_geometry_shader(tested_shader_type, function_definition, function_use, verification); 9323 const std::string& tess_ctrl_shader_source = 9324 this->prepare_tess_ctrl_shader(tested_shader_type, function_definition, function_use, verification); 9325 const std::string& tess_eval_shader_source = 9326 this->prepare_tess_eval_shader(tested_shader_type, function_definition, function_use, verification); 9327 const std::string& vertex_shader_source = 9328 this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification); 9329 9330 switch (tested_shader_type) 9331 { 9332 case TestCaseBase<API>::VERTEX_SHADER_TYPE: /* Fall through */ 9333 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 9334 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 9335 break; 9336 9337 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 9338 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9339 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 9340 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 9341 this->execute_positive_test(vertex_shader_source, tess_ctrl_shader_source, tess_eval_shader_source, 9342 geometry_shader_source, fragment_shader_source, compute_shader_source, false, 9343 false); 9344 break; 9345 9346 default: 9347 TCU_FAIL("Invalid enum"); 9348 break; 9349 } 9350 } 9351 else 9352 { 9353 const std::string& fragment_shader_source = 9354 this->prepare_fragment_shader(tested_shader_type, function_definition, function_use, verification); 9355 const std::string& vertex_shader_source = 9356 this->prepare_vertex_shader(tested_shader_type, function_definition, function_use, verification); 9357 9358 this->execute_positive_test(vertex_shader_source, fragment_shader_source, false, false); 9359 } 9360 9361 /* We are now ready to verify whether the returned size is correct. */ 9362 unsigned char buffer[4] = { 0 }; 9363 glw::GLuint framebuffer_object_id = 0; 9364 glw::GLuint routine_index = -1; 9365 glw::GLuint routine_location = -1; 9366 const glw::GLchar* routine_name = "original_routine"; 9367 glw::GLenum shader_type = 0; 9368 glw::GLuint texture_object_id = 0; 9369 glw::GLuint vao_id = 0; 9370 9371 switch (tested_shader_type) 9372 { 9373 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 9374 shader_type = GL_FRAGMENT_SHADER; 9375 break; 9376 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 9377 shader_type = GL_VERTEX_SHADER; 9378 break; 9379 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 9380 shader_type = GL_COMPUTE_SHADER; 9381 break; 9382 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9383 shader_type = GL_GEOMETRY_SHADER; 9384 break; 9385 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 9386 shader_type = GL_TESS_CONTROL_SHADER; 9387 break; 9388 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 9389 shader_type = GL_TESS_EVALUATION_SHADER; 9390 break; 9391 default: 9392 TCU_FAIL("Invalid shader type"); 9393 break; 9394 } 9395 9396 if (false == use_original) 9397 { 9398 routine_name = "new_routine"; 9399 } 9400 9401 gl.useProgram(this->program_object_id); 9402 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() failed."); 9403 9404 /* Select subroutine */ 9405 routine_index = gl.getSubroutineIndex(this->program_object_id, shader_type, routine_name); 9406 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() failed."); 9407 9408 routine_location = gl.getSubroutineUniformLocation(this->program_object_id, shader_type, "routine"); 9409 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() failed."); 9410 9411 if (0 != routine_location) 9412 { 9413 TCU_FAIL("Subroutine location is invalid"); 9414 } 9415 9416 gl.uniformSubroutinesuiv(shader_type, 1, &routine_index); 9417 GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() failed."); 9418 9419 /* Prepre texture */ 9420 assert(0 == texture_object_id); 9421 gl.genTextures(1, &texture_object_id); 9422 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed."); 9423 9424 gl.bindTexture(GL_TEXTURE_2D, texture_object_id); 9425 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed."); 9426 9427 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 1); 9428 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() failed."); 9429 9430 /* Prepare framebuffer */ 9431 assert(0 == framebuffer_object_id); 9432 gl.genFramebuffers(1, &framebuffer_object_id); 9433 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() failed."); 9434 9435 gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id); 9436 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() failed."); 9437 9438 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_object_id, 0); 9439 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() failed."); 9440 9441 gl.viewport(0, 0, 1, 1); 9442 GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() failed."); 9443 9444 /* Set VAO */ 9445 assert(0 == vao_id); 9446 gl.genVertexArrays(1, &vao_id); 9447 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() failed."); 9448 9449 gl.bindVertexArray(vao_id); 9450 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() failed."); 9451 9452 switch (tested_shader_type) 9453 { 9454 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */ 9455 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 9456 gl.drawArrays(GL_TRIANGLE_FAN, 0, 4); 9457 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 9458 break; 9459 9460 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 9461 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 9462 /* Tesselation patch set up */ 9463 gl.patchParameteri(GL_PATCH_VERTICES, 1); 9464 GLU_EXPECT_NO_ERROR(gl.getError(), "PatchParameteri"); 9465 9466 gl.drawArrays(GL_PATCHES, 0, 1); 9467 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 9468 break; 9469 9470 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9471 gl.drawArrays(GL_POINTS, 0, 1); 9472 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() failed."); 9473 break; 9474 9475 default: 9476 TCU_FAIL("Invalid enum"); 9477 break; 9478 } 9479 9480 /* Verify */ 9481 gl.readBuffer(GL_COLOR_ATTACHMENT0); 9482 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadBuffer() failed."); 9483 9484 gl.readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, buffer); 9485 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() failed."); 9486 9487 const bool result = ((buffer[0] != 255) == expect_invalid_result); 9488 9489 /* Delete generated objects. */ 9490 gl.useProgram(0); 9491 gl.bindTexture(GL_TEXTURE_2D, 0); 9492 gl.bindFramebuffer(GL_FRAMEBUFFER, 0); 9493 gl.bindVertexArray(0); 9494 9495 gl.deleteProgram(this->program_object_id); 9496 this->program_object_id = 0; 9497 9498 gl.deleteTextures(1, &texture_object_id); 9499 texture_object_id = 0; 9500 9501 gl.deleteFramebuffers(1, &framebuffer_object_id); 9502 framebuffer_object_id = 0; 9503 9504 gl.deleteVertexArrays(1, &vao_id); 9505 vao_id = 0; 9506 9507 GLU_EXPECT_NO_ERROR(gl.getError(), "An error ocurred while deleting generated objects."); 9508 9509 if (!result) 9510 { 9511 TCU_FAIL("Invalid result was returned."); 9512 } 9513 } 9514 9515 /** Prepare shader 9516 * 9517 * @tparam API Tested API descriptor 9518 * 9519 * @param tested_shader_type The type of shader that is being tested 9520 * @param function_definition Definition used to prepare shader 9521 * @param function_use Use of definition 9522 * @param verification Result verification 9523 **/ 9524 template <class API> 9525 std::string SubroutineFunctionCalls1<API>::prepare_compute_shader( 9526 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 9527 const std::string& function_use, const std::string& verification) 9528 { 9529 std::string compute_shader_source; 9530 9531 if (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type) 9532 { 9533 compute_shader_source = "writeonly uniform image2D uni_image;\n" 9534 "\n"; 9535 9536 /* User-defined function definition. */ 9537 compute_shader_source += function_definition; 9538 compute_shader_source += "\n\n"; 9539 9540 /* Main function definition. */ 9541 compute_shader_source += shader_start; 9542 compute_shader_source += function_use; 9543 compute_shader_source += "\n\n"; 9544 compute_shader_source += verification; 9545 compute_shader_source += "\n\n"; 9546 compute_shader_source += "\n" 9547 " imageStore(uni_image, ivec2(gl_GlobalInvocationID.xy), vec4(result, 0, 0, 0));\n" 9548 "}\n" 9549 "\n"; 9550 } 9551 9552 return compute_shader_source; 9553 } 9554 9555 /** Prepare shader 9556 * 9557 * @tparam API Tested API descriptor 9558 * 9559 * @param tested_shader_type The type of shader that is being tested 9560 * @param function_definition Definition used to prepare shader 9561 * @param function_use Use of definition 9562 * @param verification Result verification 9563 **/ 9564 template <class API> 9565 std::string SubroutineFunctionCalls1<API>::prepare_fragment_shader( 9566 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 9567 const std::string& function_use, const std::string& verification) 9568 { 9569 std::string fragment_shader_source; 9570 9571 switch (tested_shader_type) 9572 { 9573 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 9574 break; 9575 9576 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 9577 fragment_shader_source = "out vec4 colour;\n\n"; 9578 9579 /* User-defined function definition. */ 9580 fragment_shader_source += function_definition; 9581 fragment_shader_source += "\n\n"; 9582 9583 /* Main function definition. */ 9584 fragment_shader_source += shader_start; 9585 fragment_shader_source += function_use; 9586 fragment_shader_source += "\n\n"; 9587 fragment_shader_source += verification; 9588 fragment_shader_source += "\n\n"; 9589 fragment_shader_source += " colour = vec4(result);\n"; 9590 fragment_shader_source += shader_end; 9591 break; 9592 9593 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9594 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 9595 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: /* Fall through */ 9596 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 9597 fragment_shader_source = "in float fs_result;\n\n" 9598 "out vec4 colour;\n\n" 9599 "void main()\n" 9600 "{\n" 9601 " colour = vec4(fs_result);\n" 9602 "}\n" 9603 "\n"; 9604 break; 9605 9606 default: 9607 TCU_FAIL("Unrecognized shader object type."); 9608 break; 9609 } 9610 9611 return fragment_shader_source; 9612 } 9613 9614 /** Prepare shader 9615 * 9616 * @tparam API Tested API descriptor 9617 * 9618 * @param tested_shader_type The type of shader that is being tested 9619 * @param function_definition Definition used to prepare shader 9620 * @param function_use Use of definition 9621 * @param verification Result verification 9622 **/ 9623 template <class API> 9624 std::string SubroutineFunctionCalls1<API>::prepare_geometry_shader( 9625 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 9626 const std::string& function_use, const std::string& verification) 9627 { 9628 std::string geometry_shader_source; 9629 9630 switch (tested_shader_type) 9631 { 9632 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 9633 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: /* Fall through */ 9634 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 9635 break; 9636 9637 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: /* Fall through */ 9638 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 9639 geometry_shader_source = "layout(points) in;\n" 9640 "layout(triangle_strip, max_vertices = 4) out;\n" 9641 "\n" 9642 "in float tes_result[];\n" 9643 "out float fs_result;\n" 9644 "\n" 9645 "void main()\n" 9646 "{\n" 9647 " gl_Position = vec4(-1, -1, 0, 1);\n" 9648 " fs_result = tes_result[0];\n" 9649 " EmitVertex();\n" 9650 " gl_Position = vec4(-1, 1, 0, 1);\n" 9651 " fs_result = tes_result[0];\n" 9652 " EmitVertex();\n" 9653 " gl_Position = vec4(1, -1, 0, 1);\n" 9654 " fs_result = tes_result[0];\n" 9655 " EmitVertex();\n" 9656 " gl_Position = vec4(1, 1, 0, 1);\n" 9657 " fs_result = tes_result[0];\n" 9658 " EmitVertex();\n" 9659 "}\n"; 9660 break; 9661 9662 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9663 geometry_shader_source = "layout(points) in;\n" 9664 "layout(triangle_strip, max_vertices = 4) out;\n" 9665 "\n" 9666 "out float fs_result;\n" 9667 "\n"; 9668 9669 /* User-defined function definition. */ 9670 geometry_shader_source += function_definition; 9671 geometry_shader_source += "\n\n"; 9672 9673 /* Main function definition. */ 9674 geometry_shader_source += shader_start; 9675 geometry_shader_source += function_use; 9676 geometry_shader_source += "\n\n"; 9677 geometry_shader_source += verification; 9678 geometry_shader_source += "\n\n"; 9679 geometry_shader_source += "\n gl_Position = vec4(-1, -1, 0, 1);\n" 9680 " fs_result = result;\n" 9681 " EmitVertex();\n" 9682 " gl_Position = vec4(-1, 1, 0, 1);\n" 9683 " fs_result = result;\n" 9684 " EmitVertex();\n" 9685 " gl_Position = vec4(1, -1, 0, 1);\n" 9686 " fs_result = result;\n" 9687 " EmitVertex();\n" 9688 " gl_Position = vec4(1, 1, 0, 1);\n" 9689 " fs_result = result;\n" 9690 " EmitVertex();\n" 9691 "}\n"; 9692 break; 9693 9694 default: 9695 TCU_FAIL("Unrecognized shader object type."); 9696 break; 9697 } 9698 9699 return geometry_shader_source; 9700 } 9701 9702 /** Prepare shader 9703 * 9704 * @tparam API Tested API descriptor 9705 * 9706 * @param tested_shader_type The type of shader that is being tested 9707 * @param function_definition Definition used to prepare shader 9708 * @param function_use Use of definition 9709 * @param verification Result verification 9710 **/ 9711 template <class API> 9712 std::string SubroutineFunctionCalls1<API>::prepare_tess_ctrl_shader( 9713 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 9714 const std::string& function_use, const std::string& verification) 9715 { 9716 std::string tess_ctrl_shader_source; 9717 9718 switch (tested_shader_type) 9719 { 9720 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 9721 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 9722 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9723 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 9724 break; 9725 9726 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 9727 tess_ctrl_shader_source = "layout(vertices = 1) out;\n" 9728 "\n" 9729 "out float tcs_result[];\n" 9730 "\n"; 9731 9732 /* User-defined function definition. */ 9733 tess_ctrl_shader_source += function_definition; 9734 tess_ctrl_shader_source += "\n\n"; 9735 9736 /* Main function definition. */ 9737 tess_ctrl_shader_source += shader_start; 9738 tess_ctrl_shader_source += function_use; 9739 tess_ctrl_shader_source += "\n\n"; 9740 tess_ctrl_shader_source += verification; 9741 tess_ctrl_shader_source += "\n\n"; 9742 tess_ctrl_shader_source += " tcs_result[gl_InvocationID] = result;\n" 9743 "\n" 9744 " gl_TessLevelOuter[0] = 1.0;\n" 9745 " gl_TessLevelOuter[1] = 1.0;\n" 9746 " gl_TessLevelOuter[2] = 1.0;\n" 9747 " gl_TessLevelOuter[3] = 1.0;\n" 9748 " gl_TessLevelInner[0] = 1.0;\n" 9749 " gl_TessLevelInner[1] = 1.0;\n" 9750 "}\n"; 9751 break; 9752 9753 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 9754 tess_ctrl_shader_source = default_tc_shader_source; 9755 break; 9756 9757 default: 9758 TCU_FAIL("Unrecognized shader object type."); 9759 break; 9760 } 9761 9762 return tess_ctrl_shader_source; 9763 } 9764 9765 /** Prepare shader 9766 * 9767 * @tparam API Tested API descriptor 9768 * 9769 * @param tested_shader_type The type of shader that is being tested 9770 * @param function_definition Definition used to prepare shader 9771 * @param function_use Use of definition 9772 * @param verification Result verification 9773 **/ 9774 template <class API> 9775 std::string SubroutineFunctionCalls1<API>::prepare_tess_eval_shader( 9776 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 9777 const std::string& function_use, const std::string& verification) 9778 { 9779 std::string tess_eval_shader_source; 9780 9781 switch (tested_shader_type) 9782 { 9783 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 9784 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 9785 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9786 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 9787 break; 9788 9789 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 9790 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 9791 "\n" 9792 "in float tcs_result[];\n" 9793 "out float tes_result;\n" 9794 "\n" 9795 "void main()\n" 9796 "{\n" 9797 " tes_result = tcs_result[0];\n" 9798 "}\n"; 9799 break; 9800 9801 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 9802 tess_eval_shader_source = "layout(isolines, point_mode) in;\n" 9803 "\n" 9804 "out float tes_result;\n" 9805 "\n"; 9806 9807 /* User-defined function definition. */ 9808 tess_eval_shader_source += function_definition; 9809 tess_eval_shader_source += "\n\n"; 9810 9811 /* Main function definition. */ 9812 tess_eval_shader_source += shader_start; 9813 tess_eval_shader_source += function_use; 9814 tess_eval_shader_source += "\n\n"; 9815 tess_eval_shader_source += verification; 9816 tess_eval_shader_source += "\n\n"; 9817 tess_eval_shader_source += " tes_result = result;\n" 9818 "}\n"; 9819 break; 9820 9821 default: 9822 TCU_FAIL("Unrecognized shader object type."); 9823 break; 9824 } 9825 9826 return tess_eval_shader_source; 9827 } 9828 9829 /** Prepare shader 9830 * 9831 * @tparam API Tested API descriptor 9832 * 9833 * @param tested_shader_type The type of shader that is being tested 9834 * @param function_definition Definition used to prepare shader 9835 * @param function_use Use of definition 9836 * @param verification Result verification 9837 **/ 9838 template <class API> 9839 std::string SubroutineFunctionCalls1<API>::prepare_vertex_shader( 9840 typename TestCaseBase<API>::TestShaderType tested_shader_type, const std::string& function_definition, 9841 const std::string& function_use, const std::string& verification) 9842 { 9843 std::string vertex_shader_source; 9844 9845 switch (tested_shader_type) 9846 { 9847 case TestCaseBase<API>::COMPUTE_SHADER_TYPE: 9848 break; 9849 9850 case TestCaseBase<API>::FRAGMENT_SHADER_TYPE: 9851 vertex_shader_source = "/** GL_TRIANGLE_FAN-type quad vertex data. */\n" 9852 "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n" 9853 " vec4(-1.0, -1.0, 0.0, 1.0),\n" 9854 " vec4(-1.0, 1.0, 0.0, 1.0),\n" 9855 " vec4( 1.0, 1.0, 0.0, 1.0) );\n" 9856 "\n" 9857 "void main()\n" 9858 "{\n" 9859 " gl_Position = vertex_positions[gl_VertexID];" 9860 "}\n\n"; 9861 break; 9862 9863 case TestCaseBase<API>::GEOMETRY_SHADER_TYPE: 9864 case TestCaseBase<API>::TESSELATION_CONTROL_SHADER_TYPE: 9865 case TestCaseBase<API>::TESSELATION_EVALUATION_SHADER_TYPE: 9866 vertex_shader_source = default_vertex_shader_source; 9867 break; 9868 9869 case TestCaseBase<API>::VERTEX_SHADER_TYPE: 9870 /* Vertex shader source. */ 9871 vertex_shader_source = "out float fs_result;\n\n"; 9872 vertex_shader_source += "/** GL_TRIANGLE_FAN-type quad vertex data. */\n" 9873 "const vec4 vertex_positions[4] = vec4[4](vec4( 1.0, -1.0, 0.0, 1.0),\n" 9874 " vec4(-1.0, -1.0, 0.0, 1.0),\n" 9875 " vec4(-1.0, 1.0, 0.0, 1.0),\n" 9876 " vec4( 1.0, 1.0, 0.0, 1.0) );\n\n"; 9877 9878 /* User-defined function definition. */ 9879 vertex_shader_source += function_definition; 9880 vertex_shader_source += "\n\n"; 9881 9882 /* Main function definition. */ 9883 vertex_shader_source += shader_start; 9884 vertex_shader_source += function_use; 9885 vertex_shader_source += "\n\n"; 9886 vertex_shader_source += verification; 9887 vertex_shader_source += "\n\n"; 9888 vertex_shader_source += " fs_result = result;\n" 9889 " gl_Position = vertex_positions[gl_VertexID];\n"; 9890 vertex_shader_source += shader_end; 9891 break; 9892 9893 default: 9894 TCU_FAIL("Unrecognized shader object type."); 9895 break; 9896 } 9897 9898 return vertex_shader_source; 9899 } 9900 9901 /* Generates the shader source code for the InteractionFunctionCalls2 9902 * array tests, and attempts to build and execute test program. 9903 * 9904 * @tparam API Tested API descriptor 9905 * 9906 * @param tested_shader_type The type of shader that is being tested 9907 */ 9908 template <class API> 9909 void SubroutineFunctionCalls2<API>::test_shader_compilation( 9910 typename TestCaseBase<API>::TestShaderType tested_shader_type) 9911 { 9912 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 9913 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 9914 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 9915 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 9916 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 9917 9918 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 9919 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 9920 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 9921 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 9922 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 9923 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 9924 9925 const std::string iteration_loop_end = " }\n" 9926 " }\n" 9927 " }\n" 9928 " }\n" 9929 " }\n" 9930 " }\n" 9931 " }\n" 9932 " }\n"; 9933 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 9934 " {\n" 9935 " for (uint b = 0u; b < 2u; b++)\n" 9936 " {\n" 9937 " for (uint c = 0u; c < 2u; c++)\n" 9938 " {\n" 9939 " for (uint d = 0u; d < 2u; d++)\n" 9940 " {\n" 9941 " for (uint e = 0u; e < 2u; e++)\n" 9942 " {\n" 9943 " for (uint f = 0u; f < 2u; f++)\n" 9944 " {\n" 9945 " for (uint g = 0u; g < 2u; g++)\n" 9946 " {\n" 9947 " for (uint h = 0u; h < 2u; h++)\n" 9948 " {\n"; 9949 const std::string multiplier_array = "const int[] multiplier_array = int[]( 1, 2, 3, 4, 5, 6, 7, 8,\n" 9950 " 11, 12, 13, 14, 15, 16, 17, 18,\n" 9951 " 21, 22, 23, 24, 25, 26, 27, 28,\n" 9952 " 31, 32, 33, 34, 35, 36, 37, 38,\n" 9953 " 41, 42, 43, 44, 45, 46, 47, 48,\n" 9954 " 51, 52, 53, 54, 55, 56, 57, 58,\n" 9955 " 61, 62, 63, 64, 65, 66, 67, 68,\n" 9956 " 71, 72, 73, 74, 75, 76, 77, 78,\n" 9957 " 81, 82, 83, 84, 85, 86, 87, 88);\n"; 9958 const glcts::test_var_type* var_types_set = var_types_set_es; 9959 size_t num_var_types = num_var_types_es; 9960 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 9961 9962 if (API::USE_DOUBLE) 9963 { 9964 var_types_set = var_types_set_gl; 9965 num_var_types = num_var_types_gl; 9966 } 9967 9968 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 9969 { 9970 _supported_variable_types_map_const_iterator var_iterator = 9971 supported_variable_types_map.find(var_types_set[var_type_index]); 9972 9973 if (var_iterator != supported_variable_types_map.end()) 9974 { 9975 std::string function_definition; 9976 std::string function_use; 9977 std::string verification; 9978 9979 function_definition += multiplier_array; 9980 9981 function_definition += "// Subroutine types\n" 9982 "subroutine void inout_routine_type(inout "; 9983 function_definition += var_iterator->second.type; 9984 function_definition += " inout_array[2][2][2][2][2][2][2][2]);\n\n" 9985 "// Subroutine definitions\n" 9986 "subroutine(inout_routine_type) void original_routine(inout "; 9987 function_definition += var_iterator->second.type; 9988 function_definition += " inout_array[2][2][2][2][2][2][2][2]) {\n" 9989 " uint i = 0u;\n"; 9990 function_definition += iteration_loop_start; 9991 function_definition += " inout_array[a][b][c][d][e][f][g][h] *= " + 9992 var_iterator->second.iterator_type + "(multiplier_array[i % 64u]);\n"; 9993 function_definition += " i+= 1u;\n"; 9994 function_definition += iteration_loop_end; 9995 function_definition += "}\n\n" 9996 "subroutine(inout_routine_type) void new_routine(inout "; 9997 function_definition += var_iterator->second.type; 9998 function_definition += " inout_array[2][2][2][2][2][2][2][2]) {\n" 9999 " uint i = 0u;\n"; 10000 function_definition += iteration_loop_start; 10001 function_definition += " inout_array[a][b][c][d][e][f][g][h] /= " + 10002 var_iterator->second.iterator_type + "(multiplier_array[i % 64u]);\n"; 10003 function_definition += " i+= 1u;\n"; 10004 function_definition += iteration_loop_end; 10005 function_definition += "}\n\n" 10006 "// Subroutine uniform\n" 10007 "subroutine uniform inout_routine_type routine;\n"; 10008 10009 function_use += " float result = 1.0;\n"; 10010 function_use += " uint iterator = 0u;\n"; 10011 function_use += " " + var_iterator->second.type + " my_array[2][2][2][2][2][2][2][2];\n"; 10012 function_use += iteration_loop_start; 10013 function_use += " my_array[a][b][c][d][e][f][g][h] = " + 10014 var_iterator->second.variable_type_initializer2 + ";\n"; 10015 function_use += iteration_loop_end; 10016 function_use += " routine(my_array);"; 10017 10018 verification += iteration_loop_start; 10019 verification += " if (my_array[a][b][c][d][e][f][g][h] " + 10020 var_iterator->second.specific_element + "!= " + var_iterator->second.iterator_type + 10021 "(multiplier_array[iterator % 64u]))\n" 10022 " {\n" 10023 " result = 0.0;\n" 10024 " }\n" 10025 " iterator += 1u;\n"; 10026 verification += iteration_loop_end; 10027 10028 if (false == test_compute) 10029 { 10030 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false, 10031 true); 10032 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true, 10033 false); 10034 } 10035 else 10036 { 10037 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false, 10038 true); 10039 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true, 10040 false); 10041 } 10042 10043 /* Deallocate any resources used. */ 10044 this->delete_objects(); 10045 } /* if var_type iterator found */ 10046 else 10047 { 10048 TCU_FAIL("Type not found."); 10049 } 10050 } /* for (int var_type_index = 0; ...) */ 10051 } 10052 10053 /* Generates the shader source code for the SubroutineArgumentAliasing1 10054 * array tests, attempts to build and execute test program 10055 * 10056 * @tparam API Tested API descriptor 10057 * 10058 * @param tested_shader_type The type of shader that is being tested 10059 */ 10060 template <class API> 10061 void SubroutineArgumentAliasing1<API>::test_shader_compilation( 10062 typename TestCaseBase<API>::TestShaderType tested_shader_type) 10063 { 10064 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10065 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10066 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10067 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 10068 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 10069 10070 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10071 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10072 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10073 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 10074 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 10075 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 10076 10077 const std::string iteration_loop_end = " }\n" 10078 " }\n" 10079 " }\n" 10080 " }\n" 10081 " }\n" 10082 " }\n"; 10083 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 10084 " {\n" 10085 " for (uint b = 0u; b < 2u; b++)\n" 10086 " {\n" 10087 " for (uint c = 0u; c < 2u; c++)\n" 10088 " {\n" 10089 " for (uint d = 0u; d < 2u; d++)\n" 10090 " {\n" 10091 " for (uint e = 0u; e < 2u; e++)\n" 10092 " {\n" 10093 " for (uint f = 0u; f < 2u; f++)\n" 10094 " {\n"; 10095 const glcts::test_var_type* var_types_set = var_types_set_es; 10096 size_t num_var_types = num_var_types_es; 10097 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 10098 10099 if (API::USE_DOUBLE) 10100 { 10101 var_types_set = var_types_set_gl; 10102 num_var_types = num_var_types_gl; 10103 } 10104 10105 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 10106 { 10107 _supported_variable_types_map_const_iterator var_iterator = 10108 supported_variable_types_map.find(var_types_set[var_type_index]); 10109 10110 if (var_iterator != supported_variable_types_map.end()) 10111 { 10112 std::string function_definition; 10113 std::string function_use; 10114 std::string verification; 10115 10116 function_definition += "// Subroutine types\n" 10117 "subroutine bool in_routine_type("; 10118 function_definition += var_iterator->second.type; 10119 function_definition += " x[2][2][2][2][2][2], "; 10120 function_definition += var_iterator->second.type; 10121 function_definition += " y[2][2][2][2][2][2]);\n\n" 10122 "// Subroutine definitions\n" 10123 "subroutine(in_routine_type) bool original_routine("; 10124 function_definition += var_iterator->second.type; 10125 function_definition += " x[2][2][2][2][2][2], "; 10126 function_definition += var_iterator->second.type; 10127 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10128 function_definition += iteration_loop_start; 10129 function_definition += 10130 " x[a][b][c][d][e][f] = " + var_iterator->second.type + "(123);\n"; 10131 function_definition += iteration_loop_end; 10132 function_definition += "\n"; 10133 function_definition += iteration_loop_start; 10134 function_definition += " if(y[a][b][c][d][e][f]"; 10135 if (var_iterator->second.type == "mat4") // mat4 comparison 10136 { 10137 function_definition += "[0][0]"; 10138 function_definition += " != float"; 10139 } 10140 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10141 { 10142 function_definition += "[0][0]"; 10143 function_definition += " != double"; 10144 } 10145 else 10146 { 10147 function_definition += " != "; 10148 function_definition += var_iterator->second.type; 10149 } 10150 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10151 function_definition += iteration_loop_end; 10152 function_definition += "\n return true;\n"; 10153 function_definition += "}\n\n" 10154 "subroutine(in_routine_type) bool new_routine("; 10155 function_definition += var_iterator->second.type; 10156 function_definition += " x[2][2][2][2][2][2], "; 10157 function_definition += var_iterator->second.type; 10158 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10159 function_definition += iteration_loop_start; 10160 function_definition += 10161 " y[a][b][c][d][e][f] = " + var_iterator->second.type + "(123);\n"; 10162 function_definition += iteration_loop_end; 10163 function_definition += "\n"; 10164 function_definition += iteration_loop_start; 10165 function_definition += " if(x[a][b][c][d][e][f]"; 10166 if (var_iterator->second.type == "mat4") // mat4 comparison 10167 { 10168 function_definition += "[0][0]"; 10169 function_definition += " != float"; 10170 } 10171 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10172 { 10173 function_definition += "[0][0]"; 10174 function_definition += " != double"; 10175 } 10176 else 10177 { 10178 function_definition += " != "; 10179 function_definition += var_iterator->second.type; 10180 } 10181 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10182 function_definition += iteration_loop_end; 10183 function_definition += "\n return true;\n"; 10184 function_definition += "}\n\n" 10185 "// Subroutine uniform\n" 10186 "subroutine uniform in_routine_type routine;\n"; 10187 10188 function_use += " " + var_iterator->second.type + " z[2][2][2][2][2][2];\n"; 10189 function_use += iteration_loop_start; 10190 function_use += " z[a][b][c][d][e][f] = "; 10191 function_use += var_iterator->second.type; 10192 function_use += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f));\n"; 10193 function_use += iteration_loop_end; 10194 10195 verification = " float result = 0.0;\n" 10196 " if(routine(z, z) == true)\n" 10197 " {\n" 10198 " result = 1.0;\n" 10199 " }\n" 10200 " else\n" 10201 " {\n" 10202 " result = 0.5;\n" 10203 " }\n"; 10204 10205 if (false == test_compute) 10206 { 10207 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false, 10208 false); 10209 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true, 10210 false); 10211 } 10212 else 10213 { 10214 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false, 10215 false); 10216 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true, 10217 false); 10218 } 10219 10220 /* Deallocate any resources used. */ 10221 this->delete_objects(); 10222 } /* if var_type iterator found */ 10223 else 10224 { 10225 TCU_FAIL("Type not found."); 10226 } 10227 } /* for (int var_type_index = 0; ...) */ 10228 } 10229 10230 /* Generates the shader source code for the SubroutineArgumentAliasing1 10231 * array tests, attempts to build and execute test program 10232 * 10233 * @tparam API Tested API descriptor 10234 * 10235 * @param tested_shader_type The type of shader that is being tested 10236 */ 10237 template <class API> 10238 void SubroutineArgumentAliasing2<API>::test_shader_compilation( 10239 typename TestCaseBase<API>::TestShaderType tested_shader_type) 10240 { 10241 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10242 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10243 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10244 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 10245 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 10246 10247 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10248 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10249 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10250 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 10251 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 10252 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 10253 10254 const std::string iteration_loop_end = " }\n" 10255 " }\n" 10256 " }\n" 10257 " }\n" 10258 " }\n" 10259 " }\n"; 10260 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 10261 " {\n" 10262 " for (uint b = 0u; b < 2u; b++)\n" 10263 " {\n" 10264 " for (uint c = 0u; c < 2u; c++)\n" 10265 " {\n" 10266 " for (uint d = 0u; d < 2u; d++)\n" 10267 " {\n" 10268 " for (uint e = 0u; e < 2u; e++)\n" 10269 " {\n" 10270 " for (uint f = 0u; f < 2u; f++)\n" 10271 " {\n"; 10272 const glcts::test_var_type* var_types_set = var_types_set_es; 10273 size_t num_var_types = num_var_types_es; 10274 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 10275 10276 if (API::USE_DOUBLE) 10277 { 10278 var_types_set = var_types_set_gl; 10279 num_var_types = num_var_types_gl; 10280 } 10281 10282 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 10283 { 10284 _supported_variable_types_map_const_iterator var_iterator = 10285 supported_variable_types_map.find(var_types_set[var_type_index]); 10286 10287 if (var_iterator != supported_variable_types_map.end()) 10288 { 10289 std::string function_definition; 10290 std::string function_use; 10291 std::string verification; 10292 10293 function_definition += "// Subroutine types\n" 10294 "subroutine bool inout_routine_type(inout "; 10295 function_definition += var_iterator->second.type; 10296 function_definition += " x[2][2][2][2][2][2], inout "; 10297 function_definition += var_iterator->second.type; 10298 function_definition += " y[2][2][2][2][2][2]);\n\n" 10299 "// Subroutine definitions\n" 10300 "subroutine(inout_routine_type) bool original_routine(inout "; 10301 function_definition += var_iterator->second.type; 10302 function_definition += " x[2][2][2][2][2][2], inout "; 10303 function_definition += var_iterator->second.type; 10304 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10305 function_definition += iteration_loop_start; 10306 function_definition += 10307 " x[a][b][c][d][e][f] = " + var_iterator->second.type + "(123);\n"; 10308 function_definition += iteration_loop_end; 10309 function_definition += "\n"; 10310 function_definition += iteration_loop_start; 10311 function_definition += " if(y[a][b][c][d][e][f]"; 10312 if (var_iterator->second.type == "mat4") // mat4 comparison 10313 { 10314 function_definition += "[0][0]"; 10315 function_definition += " != float"; 10316 } 10317 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10318 { 10319 function_definition += "[0][0]"; 10320 function_definition += " != double"; 10321 } 10322 else 10323 { 10324 function_definition += " != "; 10325 function_definition += var_iterator->second.type; 10326 } 10327 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10328 function_definition += iteration_loop_end; 10329 function_definition += "\n return true;\n"; 10330 function_definition += "}\n\n" 10331 "subroutine(inout_routine_type) bool new_routine(inout "; 10332 function_definition += var_iterator->second.type; 10333 function_definition += " x[2][2][2][2][2][2], inout "; 10334 function_definition += var_iterator->second.type; 10335 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10336 function_definition += iteration_loop_start; 10337 function_definition += 10338 " y[a][b][c][d][e][f] = " + var_iterator->second.type + "(123);\n"; 10339 function_definition += iteration_loop_end; 10340 function_definition += "\n"; 10341 function_definition += iteration_loop_start; 10342 function_definition += " if(x[a][b][c][d][e][f]"; 10343 if (var_iterator->second.type == "mat4") // mat4 comparison 10344 { 10345 function_definition += "[0][0]"; 10346 function_definition += " != float"; 10347 } 10348 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10349 { 10350 function_definition += "[0][0]"; 10351 function_definition += " != double"; 10352 } 10353 else 10354 { 10355 function_definition += " != "; 10356 function_definition += var_iterator->second.type; 10357 } 10358 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10359 function_definition += iteration_loop_end; 10360 function_definition += "\n return true;\n"; 10361 function_definition += "}\n\n" 10362 "// Subroutine uniform\n" 10363 "subroutine uniform inout_routine_type routine;\n"; 10364 10365 function_use += " " + var_iterator->second.type + " z[2][2][2][2][2][2];\n"; 10366 function_use += iteration_loop_start; 10367 function_use += " z[a][b][c][d][e][f] = "; 10368 function_use += var_iterator->second.type; 10369 function_use += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f));\n"; 10370 function_use += iteration_loop_end; 10371 10372 verification = " float result = 0.0;\n" 10373 " if(routine(z, z) == true)\n" 10374 " {\n" 10375 " result = 1.0;\n" 10376 " }\n" 10377 " else\n" 10378 " {\n" 10379 " result = 0.5;\n" 10380 " }\n"; 10381 10382 if (false == test_compute) 10383 { 10384 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false, 10385 false); 10386 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true, 10387 false); 10388 } 10389 else 10390 { 10391 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false, 10392 false); 10393 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true, 10394 false); 10395 } 10396 10397 /* Deallocate any resources used. */ 10398 this->delete_objects(); 10399 } /* if var_type iterator found */ 10400 else 10401 { 10402 TCU_FAIL("Type not found."); 10403 } 10404 } /* for (int var_type_index = 0; ...) */ 10405 } 10406 10407 /* Generates the shader source code for the SubroutineArgumentAliasing1 10408 * array tests, attempts to build and execute test program 10409 * 10410 * @tparam API Tested API descriptor 10411 * 10412 * @param tested_shader_type The type of shader that is being tested 10413 */ 10414 template <class API> 10415 void SubroutineArgumentAliasing3<API>::test_shader_compilation( 10416 typename TestCaseBase<API>::TestShaderType tested_shader_type) 10417 { 10418 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10419 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10420 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10421 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 10422 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 10423 10424 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10425 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10426 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10427 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 10428 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 10429 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 10430 10431 const std::string iteration_loop_end = " }\n" 10432 " }\n" 10433 " }\n" 10434 " }\n" 10435 " }\n" 10436 " }\n"; 10437 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 10438 " {\n" 10439 " for (uint b = 0u; b < 2u; b++)\n" 10440 " {\n" 10441 " for (uint c = 0u; c < 2u; c++)\n" 10442 " {\n" 10443 " for (uint d = 0u; d < 2u; d++)\n" 10444 " {\n" 10445 " for (uint e = 0u; e < 2u; e++)\n" 10446 " {\n" 10447 " for (uint f = 0u; f < 2u; f++)\n" 10448 " {\n"; 10449 const glcts::test_var_type* var_types_set = var_types_set_es; 10450 size_t num_var_types = num_var_types_es; 10451 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 10452 10453 if (API::USE_DOUBLE) 10454 { 10455 var_types_set = var_types_set_gl; 10456 num_var_types = num_var_types_gl; 10457 } 10458 10459 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 10460 { 10461 _supported_variable_types_map_const_iterator var_iterator = 10462 supported_variable_types_map.find(var_types_set[var_type_index]); 10463 10464 if (var_iterator != supported_variable_types_map.end()) 10465 { 10466 std::string function_definition; 10467 std::string function_use; 10468 std::string verification; 10469 10470 function_definition += "// Subroutine types\n" 10471 "subroutine bool out_routine_type(out "; 10472 function_definition += var_iterator->second.type; 10473 function_definition += " x[2][2][2][2][2][2], "; 10474 function_definition += var_iterator->second.type; 10475 function_definition += " y[2][2][2][2][2][2]);\n\n" 10476 "// Subroutine definitions\n" 10477 "subroutine(out_routine_type) bool original_routine(out "; 10478 function_definition += var_iterator->second.type; 10479 function_definition += " x[2][2][2][2][2][2], "; 10480 function_definition += var_iterator->second.type; 10481 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10482 function_definition += iteration_loop_start; 10483 function_definition += 10484 " x[a][b][c][d][e][f] = " + var_iterator->second.type + "(123);\n"; 10485 function_definition += iteration_loop_end; 10486 function_definition += "\n"; 10487 function_definition += iteration_loop_start; 10488 function_definition += " if(y[a][b][c][d][e][f]"; 10489 if (var_iterator->second.type == "mat4") // mat4 comparison 10490 { 10491 function_definition += "[0][0]"; 10492 function_definition += " != float"; 10493 } 10494 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10495 { 10496 function_definition += "[0][0]"; 10497 function_definition += " != double"; 10498 } 10499 else 10500 { 10501 function_definition += " != "; 10502 function_definition += var_iterator->second.type; 10503 } 10504 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10505 function_definition += iteration_loop_end; 10506 function_definition += "\n return true;\n"; 10507 function_definition += "}\n\n" 10508 "subroutine(out_routine_type) bool new_routine(out "; 10509 function_definition += var_iterator->second.type; 10510 function_definition += " x[2][2][2][2][2][2], "; 10511 function_definition += var_iterator->second.type; 10512 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10513 function_definition += iteration_loop_start; 10514 function_definition += 10515 " x[a][b][c][d][e][f] = " + var_iterator->second.type + "(321);\n"; 10516 function_definition += iteration_loop_end; 10517 function_definition += "\n"; 10518 function_definition += iteration_loop_start; 10519 function_definition += " if(y[a][b][c][d][e][f]"; 10520 if (var_iterator->second.type == "mat4") // mat4 comparison 10521 { 10522 function_definition += "[0][0]"; 10523 function_definition += " != float"; 10524 } 10525 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10526 { 10527 function_definition += "[0][0]"; 10528 function_definition += " != double"; 10529 } 10530 else 10531 { 10532 function_definition += " != "; 10533 function_definition += var_iterator->second.type; 10534 } 10535 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10536 function_definition += iteration_loop_end; 10537 function_definition += "\n return true;\n"; 10538 function_definition += "}\n\n" 10539 "// Subroutine uniform\n" 10540 "subroutine uniform out_routine_type routine;\n"; 10541 10542 function_use += " " + var_iterator->second.type + " z[2][2][2][2][2][2];\n"; 10543 function_use += iteration_loop_start; 10544 function_use += " z[a][b][c][d][e][f] = "; 10545 function_use += var_iterator->second.type; 10546 function_use += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f));\n"; 10547 function_use += iteration_loop_end; 10548 10549 verification = " float result = 0.0;\n" 10550 " if(routine(z, z) == true)\n" 10551 " {\n" 10552 " result = 1.0;\n" 10553 " }\n" 10554 " else\n" 10555 " {\n" 10556 " result = 0.5;\n" 10557 " }\n"; 10558 10559 if (false == test_compute) 10560 { 10561 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false, 10562 false); 10563 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true, 10564 false); 10565 } 10566 else 10567 { 10568 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false, 10569 false); 10570 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true, 10571 false); 10572 } 10573 10574 /* Deallocate any resources used. */ 10575 this->delete_objects(); 10576 } /* if var_type iterator found */ 10577 else 10578 { 10579 TCU_FAIL("Type not found."); 10580 } 10581 } /* for (int var_type_index = 0; ...) */ 10582 } 10583 10584 /* Generates the shader source code for the SubroutineArgumentAliasing1 10585 * array tests, attempts to build and execute test program 10586 * 10587 * @tparam API Tested API descriptor 10588 * 10589 * @param tested_shader_type The type of shader that is being tested 10590 */ 10591 template <class API> 10592 void SubroutineArgumentAliasing4<API>::test_shader_compilation( 10593 typename TestCaseBase<API>::TestShaderType tested_shader_type) 10594 { 10595 static const glcts::test_var_type var_types_set_es[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10596 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10597 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10598 VAR_TYPE_MAT3, VAR_TYPE_MAT4 }; 10599 static const size_t num_var_types_es = sizeof(var_types_set_es) / sizeof(var_types_set_es[0]); 10600 10601 static const glcts::test_var_type var_types_set_gl[] = { VAR_TYPE_INT, VAR_TYPE_FLOAT, VAR_TYPE_IVEC2, 10602 VAR_TYPE_IVEC3, VAR_TYPE_IVEC4, VAR_TYPE_VEC2, 10603 VAR_TYPE_VEC3, VAR_TYPE_VEC4, VAR_TYPE_MAT2, 10604 VAR_TYPE_MAT3, VAR_TYPE_MAT4, VAR_TYPE_DOUBLE, 10605 VAR_TYPE_DMAT2, VAR_TYPE_DMAT3, VAR_TYPE_DMAT4 }; 10606 static const size_t num_var_types_gl = sizeof(var_types_set_gl) / sizeof(var_types_set_gl[0]); 10607 10608 const std::string iteration_loop_end = " }\n" 10609 " }\n" 10610 " }\n" 10611 " }\n" 10612 " }\n" 10613 " }\n"; 10614 const std::string iteration_loop_start = " for (uint a = 0u; a < 2u; a++)\n" 10615 " {\n" 10616 " for (uint b = 0u; b < 2u; b++)\n" 10617 " {\n" 10618 " for (uint c = 0u; c < 2u; c++)\n" 10619 " {\n" 10620 " for (uint d = 0u; d < 2u; d++)\n" 10621 " {\n" 10622 " for (uint e = 0u; e < 2u; e++)\n" 10623 " {\n" 10624 " for (uint f = 0u; f < 2u; f++)\n" 10625 " {\n"; 10626 const glcts::test_var_type* var_types_set = var_types_set_es; 10627 size_t num_var_types = num_var_types_es; 10628 const bool test_compute = (TestCaseBase<API>::COMPUTE_SHADER_TYPE == tested_shader_type); 10629 10630 if (API::USE_DOUBLE) 10631 { 10632 var_types_set = var_types_set_gl; 10633 num_var_types = num_var_types_gl; 10634 } 10635 10636 for (size_t var_type_index = 0; var_type_index < num_var_types; var_type_index++) 10637 { 10638 _supported_variable_types_map_const_iterator var_iterator = 10639 supported_variable_types_map.find(var_types_set[var_type_index]); 10640 10641 if (var_iterator != supported_variable_types_map.end()) 10642 { 10643 std::string function_definition; 10644 std::string function_use; 10645 std::string verification; 10646 10647 function_definition += "// Subroutine types\n" 10648 "subroutine bool out_routine_type("; 10649 function_definition += var_iterator->second.type; 10650 function_definition += " x[2][2][2][2][2][2], out "; 10651 function_definition += var_iterator->second.type; 10652 function_definition += " y[2][2][2][2][2][2]);\n\n" 10653 "// Subroutine definitions\n" 10654 "subroutine(out_routine_type) bool original_routine("; 10655 function_definition += var_iterator->second.type; 10656 function_definition += " x[2][2][2][2][2][2], out "; 10657 function_definition += var_iterator->second.type; 10658 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10659 function_definition += iteration_loop_start; 10660 function_definition += 10661 " y[a][b][c][d][e][f] = " + var_iterator->second.type + "(123);\n"; 10662 function_definition += iteration_loop_end; 10663 function_definition += "\n"; 10664 function_definition += iteration_loop_start; 10665 function_definition += " if(x[a][b][c][d][e][f]"; 10666 if (var_iterator->second.type == "mat4") // mat4 comparison 10667 { 10668 function_definition += "[0][0]"; 10669 function_definition += " != float"; 10670 } 10671 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10672 { 10673 function_definition += "[0][0]"; 10674 function_definition += " != double"; 10675 } 10676 else 10677 { 10678 function_definition += " != "; 10679 function_definition += var_iterator->second.type; 10680 } 10681 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10682 function_definition += iteration_loop_end; 10683 function_definition += "\n return true;\n"; 10684 function_definition += "}\n\n" 10685 "subroutine(out_routine_type) bool new_routine("; 10686 function_definition += var_iterator->second.type; 10687 function_definition += " x[2][2][2][2][2][2], out "; 10688 function_definition += var_iterator->second.type; 10689 function_definition += " y[2][2][2][2][2][2])\n{\n"; 10690 function_definition += iteration_loop_start; 10691 function_definition += 10692 " y[a][b][c][d][e][f] = " + var_iterator->second.type + "(321);\n"; 10693 function_definition += iteration_loop_end; 10694 function_definition += "\n"; 10695 function_definition += iteration_loop_start; 10696 function_definition += " if(x[a][b][c][d][e][f]"; 10697 if (var_iterator->second.type == "mat4") // mat4 comparison 10698 { 10699 function_definition += "[0][0]"; 10700 function_definition += " != float"; 10701 } 10702 else if (var_iterator->second.type == "dmat4") // dmat4 comparison 10703 { 10704 function_definition += "[0][0]"; 10705 function_definition += " != double"; 10706 } 10707 else 10708 { 10709 function_definition += " != "; 10710 function_definition += var_iterator->second.type; 10711 } 10712 function_definition += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f))) {return false;}\n"; 10713 function_definition += iteration_loop_end; 10714 function_definition += "\n return true;\n"; 10715 function_definition += "}\n\n" 10716 "// Subroutine uniform\n" 10717 "subroutine uniform out_routine_type routine;\n"; 10718 10719 function_use += " " + var_iterator->second.type + " z[2][2][2][2][2][2];\n"; 10720 function_use += iteration_loop_start; 10721 function_use += " z[a][b][c][d][e][f] = "; 10722 function_use += var_iterator->second.type; 10723 function_use += "(((a*32u)+(b*16u)+(c*8u)+(d*4u)+(e*2u)+f));\n"; 10724 function_use += iteration_loop_end; 10725 10726 verification = " float result = 0.0;\n" 10727 " if(routine(z, z) == true)\n" 10728 " {\n" 10729 " result = 1.0;\n" 10730 " }\n" 10731 " else\n" 10732 " {\n" 10733 " result = 0.5;\n" 10734 " }\n"; 10735 10736 if (false == test_compute) 10737 { 10738 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, false, 10739 false); 10740 this->execute_draw_test(tested_shader_type, function_definition, function_use, verification, true, 10741 false); 10742 } 10743 else 10744 { 10745 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, false, 10746 false); 10747 this->execute_dispatch_test(tested_shader_type, function_definition, function_use, verification, true, 10748 false); 10749 } 10750 10751 /* Deallocate any resources used. */ 10752 this->delete_objects(); 10753 } /* if var_type iterator found */ 10754 else 10755 { 10756 TCU_FAIL("Type not found."); 10757 } 10758 } /* for (int var_type_index = 0; ...) */ 10759 } 10760 10761 /** Instantiates all tests and adds them as children to the node 10762 * 10763 * @tparam API Tested API descriptor 10764 * 10765 * @param context CTS context 10766 **/ 10767 template <class API> 10768 void initTests(TestCaseGroup& group, glcts::Context& context) 10769 { 10770 // Set up the map 10771 ArraysOfArrays::initializeMap<API>(); 10772 10773 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsPrimitive<API>(context)); 10774 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes1<API>(context)); 10775 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes2<API>(context)); 10776 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes3<API>(context)); 10777 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsStructTypes4<API>(context)); 10778 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle1<API>(context)); 10779 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle2<API>(context)); 10780 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle3<API>(context)); 10781 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle4<API>(context)); 10782 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsTypenameStyle5<API>(context)); 10783 group.addChild(new glcts::ArraysOfArrays::SizedDeclarationsFunctionParams<API>(context)); 10784 group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes1<API>(context)); 10785 group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes2<API>(context)); 10786 group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes3<API>(context)); 10787 group.addChild(new glcts::ArraysOfArrays::sized_declarations_invalid_sizes4<API>(context)); 10788 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructors1<API>(context)); 10789 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructors2<API>(context)); 10790 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedConstructors<API>(context)); 10791 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConst<API>(context)); 10792 10793 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors1<API>(context)); 10794 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors2<API>(context)); 10795 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors3<API>(context)); 10796 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclInvalidConstructors4<API>(context)); 10797 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructorSizing1<API>(context)); 10798 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclConstructorSizing2<API>(context)); 10799 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclStructConstructors<API>(context)); 10800 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays1<API>(context)); 10801 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays2<API>(context)); 10802 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays3<API>(context)); 10803 group.addChild(new glcts::ArraysOfArrays::ConstructorsAndUnsizedDeclUnsizedArrays4<API>(context)); 10804 group.addChild(new glcts::ArraysOfArrays::ExpressionsAssignment1<API>(context)); 10805 group.addChild(new glcts::ArraysOfArrays::ExpressionsAssignment2<API>(context)); 10806 group.addChild(new glcts::ArraysOfArrays::ExpressionsAssignment3<API>(context)); 10807 group.addChild(new glcts::ArraysOfArrays::ExpressionsTypeRestrictions1<API>(context)); 10808 group.addChild(new glcts::ArraysOfArrays::ExpressionsTypeRestrictions2<API>(context)); 10809 group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar1<API>(context)); 10810 group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar2<API>(context)); 10811 group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar3<API>(context)); 10812 group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingScalar4<API>(context)); 10813 group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingArray1<API>(context)); 10814 group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingArray2<API>(context)); 10815 group.addChild(new glcts::ArraysOfArrays::ExpressionsIndexingArray3<API>(context)); 10816 group.addChild(new glcts::ArraysOfArrays::ExpressionsDynamicIndexing1<API>(context)); 10817 group.addChild(new glcts::ArraysOfArrays::ExpressionsDynamicIndexing2<API>(context)); 10818 group.addChild(new glcts::ArraysOfArrays::ExpressionsEquality1<API>(context)); 10819 group.addChild(new glcts::ArraysOfArrays::ExpressionsEquality2<API>(context)); 10820 group.addChild(new glcts::ArraysOfArrays::ExpressionsLength1<API>(context)); 10821 group.addChild(new glcts::ArraysOfArrays::ExpressionsLength2<API>(context)); 10822 group.addChild(new glcts::ArraysOfArrays::ExpressionsLength3<API>(context)); 10823 group.addChild(new glcts::ArraysOfArrays::ExpressionsInvalid1<API>(context)); 10824 group.addChild(new glcts::ArraysOfArrays::ExpressionsInvalid2<API>(context)); 10825 10826 group.addChild(new glcts::ArraysOfArrays::InteractionFunctionCalls1<API>(context)); 10827 group.addChild(new glcts::ArraysOfArrays::InteractionFunctionCalls2<API>(context)); 10828 group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing1<API>(context)); 10829 group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing2<API>(context)); 10830 group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing3<API>(context)); 10831 group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing4<API>(context)); 10832 group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing5<API>(context)); 10833 group.addChild(new glcts::ArraysOfArrays::InteractionArgumentAliasing6<API>(context)); 10834 10835 group.addChild(new glcts::ArraysOfArrays::InteractionUniforms1<API>(context)); 10836 group.addChild(new glcts::ArraysOfArrays::InteractionUniforms2<API>(context)); 10837 group.addChild(new glcts::ArraysOfArrays::InteractionUniformBuffers1<API>(context)); 10838 group.addChild(new glcts::ArraysOfArrays::InteractionUniformBuffers2<API>(context)); 10839 group.addChild(new glcts::ArraysOfArrays::InteractionUniformBuffers3<API>(context)); 10840 group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays1<API>(context)); 10841 group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays2<API>(context)); 10842 group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays3<API>(context)); 10843 group.addChild(new glcts::ArraysOfArrays::InteractionInterfaceArrays4<API>(context)); 10844 10845 if (API::USE_STORAGE_BLOCK) 10846 { 10847 group.addChild(new glcts::ArraysOfArrays::InteractionStorageBuffers1<API>(context)); 10848 group.addChild(new glcts::ArraysOfArrays::InteractionStorageBuffers2<API>(context)); 10849 group.addChild(new glcts::ArraysOfArrays::InteractionStorageBuffers3<API>(context)); 10850 } 10851 10852 if (API::USE_ATOMIC) 10853 { 10854 group.addChild(new glcts::ArraysOfArrays::AtomicDeclarationTest<API>(context)); 10855 group.addChild(new glcts::ArraysOfArrays::AtomicUsageTest<API>(context)); 10856 } 10857 10858 if (API::USE_SUBROUTINE) 10859 { 10860 group.addChild(new glcts::ArraysOfArrays::SubroutineFunctionCalls1<API>(context)); 10861 group.addChild(new glcts::ArraysOfArrays::SubroutineFunctionCalls2<API>(context)); 10862 group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing1<API>(context)); 10863 group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing2<API>(context)); 10864 group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing3<API>(context)); 10865 group.addChild(new glcts::ArraysOfArrays::SubroutineArgumentAliasing4<API>(context)); 10866 } 10867 } 10868 } /* namespace ArraysOfArrays */ 10869 10870 /** Constructor 10871 * 10872 * @param context CTS context 10873 **/ 10874 ArrayOfArraysTestGroup::ArrayOfArraysTestGroup(Context& context) 10875 : TestCaseGroup(context, "arrays_of_arrays", "Groups all tests that verify 'arrays of arrays' functionality.") 10876 { 10877 /* Left blank on purpose */ 10878 } 10879 10880 /* Instantiates all tests and adds them as children to the node */ 10881 void ArrayOfArraysTestGroup::init(void) 10882 { 10883 ArraysOfArrays::initTests<ArraysOfArrays::Interface::ES>(*this, m_context); 10884 } 10885 10886 /** Constructor 10887 * 10888 * @param context CTS context 10889 **/ 10890 ArrayOfArraysTestGroupGL::ArrayOfArraysTestGroupGL(Context& context) 10891 : TestCaseGroup(context, "arrays_of_arrays_gl", "Groups all tests that verify 'arrays of arrays' functionality.") 10892 { 10893 /* Left blank on purpose */ 10894 } 10895 10896 /* Instantiates all tests and adds them as children to the node */ 10897 void ArrayOfArraysTestGroupGL::init(void) 10898 { 10899 ArraysOfArrays::initTests<ArraysOfArrays::Interface::GL>(*this, m_context); 10900 } 10901 } /* namespace glcts */ 10902
