Home | History | Annotate | Download | only in gpu_shader5 
      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 /*!
     25  * \file esextcGPUShader5TextureGatherOffset.cpp
     26  * \brief gpu_shader5 extension - texture gather offset tests (Test 9 and 10)
     27  */ /*-------------------------------------------------------------------*/
     28 
     29 #include "esextcGPUShader5TextureGatherOffset.hpp"
     30 
     31 #include "gluContextInfo.hpp"
     32 #include "glwEnums.hpp"
     33 #include "glwFunctions.hpp"
     34 #include "tcuTestLog.hpp"
     35 
     36 #include <cstdlib>
     37 #include <cstring>
     38 #include <sstream>
     39 
     40 namespace glcts
     41 {
     42 
     43 /* Fragment Shader for GPUShader5TextureGatherOffsetTestBase */
     44 const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_fragment_shader_code =
     45 	"${VERSION}\n"
     46 	"\n"
     47 	"${GPU_SHADER5_REQUIRE}\n"
     48 	"\n"
     49 	"precision highp float;\n"
     50 	"\n"
     51 	"layout(location = 0) out vec4 fs_out_color;\n"
     52 	"\n"
     53 	"void main()\n"
     54 	"{\n"
     55 	"    fs_out_color = vec4(1, 1, 1, 1);\n"
     56 	"}\n";
     57 
     58 /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DRepeatCaseTest */
     59 const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::m_vertex_shader_code =
     60 	"${VERSION}\n"
     61 	"\n"
     62 	"${GPU_SHADER5_REQUIRE}\n"
     63 	"\n"
     64 	"precision highp float;\n"
     65 	"precision highp isampler2D;\n"
     66 	"\n"
     67 	"uniform isampler2D sampler;\n"
     68 	"\n"
     69 	"in ivec2 offsets;\n"
     70 	"in vec2  texCoords;\n"
     71 	"\n"
     72 	"flat out ivec4 without_offset_0;\n"
     73 	"flat out ivec4 without_offset_1;\n"
     74 	"flat out ivec4 without_offset_2;\n"
     75 	"flat out ivec4 without_offset_3;\n"
     76 	"\n"
     77 	"flat out ivec4 with_offset_0;\n"
     78 	"flat out ivec4 with_offset_1;\n"
     79 	"flat out ivec4 with_offset_2;\n"
     80 	"flat out ivec4 with_offset_3;\n"
     81 	"\n"
     82 	"void main()\n"
     83 	"{\n"
     84 	"    without_offset_0 = textureGather      (sampler, texCoords, 0);\n"
     85 	"    without_offset_1 = textureGather      (sampler, texCoords, 1);\n"
     86 	"    without_offset_2 = textureGather      (sampler, texCoords, 2);\n"
     87 	"    without_offset_3 = textureGather      (sampler, texCoords, 3);\n"
     88 	"\n"
     89 	"    with_offset_0    = textureGatherOffset(sampler, texCoords, offsets, 0);\n"
     90 	"    with_offset_1    = textureGatherOffset(sampler, texCoords, offsets, 1);\n"
     91 	"    with_offset_2    = textureGatherOffset(sampler, texCoords, offsets, 2);\n"
     92 	"    with_offset_3    = textureGatherOffset(sampler, texCoords, offsets, 3);\n"
     93 	"}\n";
     94 
     95 /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DArrayCaseTest */
     96 const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DArrayCaseTest::m_vertex_shader_code =
     97 	"${VERSION}\n"
     98 	"\n"
     99 	"${GPU_SHADER5_REQUIRE}\n"
    100 	"\n"
    101 	"precision highp float;\n"
    102 	"precision highp isampler2DArray;\n"
    103 	"\n"
    104 	"uniform isampler2DArray sampler;\n"
    105 	"\n"
    106 	"in ivec2 offsets;\n"
    107 	"in vec3  texCoords;\n"
    108 	"\n"
    109 	"flat out ivec4 without_offset_0;\n"
    110 	"flat out ivec4 without_offset_1;\n"
    111 	"flat out ivec4 without_offset_2;\n"
    112 	"flat out ivec4 without_offset_3;\n"
    113 	"\n"
    114 	"flat out ivec4 with_offset_0;\n"
    115 	"flat out ivec4 with_offset_1;\n"
    116 	"flat out ivec4 with_offset_2;\n"
    117 	"flat out ivec4 with_offset_3;\n"
    118 	"\n"
    119 	"void main()\n"
    120 	"{\n"
    121 	"    without_offset_0 = textureGather      (sampler, texCoords, 0);\n"
    122 	"    without_offset_1 = textureGather      (sampler, texCoords, 1);\n"
    123 	"    without_offset_2 = textureGather      (sampler, texCoords, 2);\n"
    124 	"    without_offset_3 = textureGather      (sampler, texCoords, 3);\n"
    125 	"\n"
    126 	"    with_offset_0    = textureGatherOffset(sampler, texCoords, offsets, 0);\n"
    127 	"    with_offset_1    = textureGatherOffset(sampler, texCoords, offsets, 1);\n"
    128 	"    with_offset_2    = textureGatherOffset(sampler, texCoords, offsets, 2);\n"
    129 	"    with_offset_3    = textureGatherOffset(sampler, texCoords, offsets, 3);\n"
    130 	"}\n";
    131 
    132 /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest */
    133 const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::m_vertex_shader_code =
    134 	"${VERSION}\n"
    135 	"\n"
    136 	"${GPU_SHADER5_REQUIRE}\n"
    137 	"\n"
    138 	"precision highp float;\n"
    139 	"precision highp isampler2D;\n"
    140 	"\n"
    141 	"uniform isampler2D sampler;\n"
    142 	"\n"
    143 	"in ivec2 offsets;\n"
    144 	"in vec2  texCoords;\n"
    145 	"\n"
    146 	"flat out ivec4 without_offset_0;\n"
    147 	"flat out ivec4 without_offset_1;\n"
    148 	"flat out ivec4 without_offset_2;\n"
    149 	"flat out ivec4 without_offset_3;\n"
    150 	"\n"
    151 	"flat out ivec4 with_offset_0;\n"
    152 	"flat out ivec4 with_offset_1;\n"
    153 	"flat out ivec4 with_offset_2;\n"
    154 	"flat out ivec4 with_offset_3;\n"
    155 	"\n"
    156 	"void main()\n"
    157 	"{\n"
    158 	"    vec2 floorTexCoords = floor(texCoords);\n"
    159 	"    vec2 fractTexCoords = texCoords - floorTexCoords;\n"
    160 	"\n"
    161 	"    without_offset_0 = textureGather      (sampler, fractTexCoords, 0);\n"
    162 	"    without_offset_1 = textureGather      (sampler, fractTexCoords, 1);\n"
    163 	"\n"
    164 	"    without_offset_2 = ivec4(int(floorTexCoords.x));\n"
    165 	"    without_offset_3 = ivec4(int(floorTexCoords.y));\n"
    166 	"\n"
    167 	"    with_offset_0    = textureGatherOffset(sampler, texCoords, offsets, 0);\n"
    168 	"    with_offset_1    = textureGatherOffset(sampler, texCoords, offsets, 1);\n"
    169 	"    with_offset_2    = textureGatherOffset(sampler, texCoords, offsets, 2);\n"
    170 	"    with_offset_3    = textureGatherOffset(sampler, texCoords, offsets, 3);\n"
    171 	"}\n";
    172 
    173 /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest */
    174 const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::m_vertex_shader_code =
    175 	"${VERSION}\n"
    176 	"\n"
    177 	"${GPU_SHADER5_REQUIRE}\n"
    178 	"\n"
    179 	"precision highp float;\n"
    180 	"precision highp isampler2D;\n"
    181 	"\n"
    182 	"uniform isampler2D sampler;\n"
    183 	"uniform isampler2D reference_sampler;\n"
    184 	"\n"
    185 	"in ivec2 offsets;\n"
    186 	"in vec2  texCoords;\n"
    187 	"\n"
    188 	"flat out ivec4 without_offset_0;\n"
    189 	"flat out ivec4 without_offset_1;\n"
    190 	"flat out ivec4 without_offset_2;\n"
    191 	"flat out ivec4 without_offset_3;\n"
    192 	"\n"
    193 	"flat out ivec4 with_offset_0;\n"
    194 	"flat out ivec4 with_offset_1;\n"
    195 	"flat out ivec4 with_offset_2;\n"
    196 	"flat out ivec4 with_offset_3;\n"
    197 	"\n"
    198 	"void main()\n"
    199 	"{\n"
    200 	"    vec2 floorTexCoords = floor(texCoords);\n"
    201 	"    vec2 fractTexCoords = texCoords - floorTexCoords;\n"
    202 	"\n"
    203 	"    without_offset_0 = textureGather      (reference_sampler, fractTexCoords, 0);\n"
    204 	"    without_offset_1 = textureGather      (reference_sampler, fractTexCoords, 1);\n"
    205 	"\n"
    206 	"    without_offset_2 = ivec4(int(floorTexCoords.x));\n"
    207 	"    without_offset_3 = ivec4(int(floorTexCoords.y));\n"
    208 	"\n"
    209 	"    with_offset_0    = textureGatherOffset(sampler, texCoords, offsets, 0);\n"
    210 	"    with_offset_1    = textureGatherOffset(sampler, texCoords, offsets, 1);\n"
    211 	"    with_offset_2    = textureGatherOffset(sampler, texCoords, offsets, 2);\n"
    212 	"    with_offset_3    = textureGatherOffset(sampler, texCoords, offsets, 3);\n"
    213 	"}\n";
    214 
    215 /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest */
    216 const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::m_vertex_shader_code_preamble =
    217 	"${VERSION}\n"
    218 	"\n"
    219 	"${GPU_SHADER5_REQUIRE}\n"
    220 	"\n"
    221 	"precision highp float;\n"
    222 	"precision highp isampler2D;\n"
    223 	"\n"
    224 	"uniform isampler2D sampler;\n"
    225 	"\n"
    226 	"in vec2  texCoords;\n"
    227 	"\n"
    228 	"flat out ivec4 without_offset_0;\n"
    229 	"flat out ivec4 without_offset_1;\n"
    230 	"flat out ivec4 without_offset_2;\n"
    231 	"flat out ivec4 without_offset_3;\n"
    232 	"\n"
    233 	"flat out ivec4 with_offset_0;\n"
    234 	"flat out ivec4 with_offset_1;\n"
    235 	"flat out ivec4 with_offset_2;\n"
    236 	"flat out ivec4 with_offset_3;\n"
    237 	"\n"
    238 	"void main()\n"
    239 	"{\n"
    240 	"    const ivec2 offsets[4] = \n";
    241 
    242 const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::m_vertex_shader_code_body =
    243 	"\n"
    244 	"    without_offset_0 = textureGather       (sampler, texCoords, 0);\n"
    245 	"    without_offset_1 = textureGather       (sampler, texCoords, 1);\n"
    246 	"    without_offset_2 = textureGather       (sampler, texCoords, 2);\n"
    247 	"    without_offset_3 = textureGather       (sampler, texCoords, 3);\n"
    248 	"\n"
    249 	"    with_offset_0    = textureGatherOffsets(sampler, texCoords, offsets, 0);\n"
    250 	"    with_offset_1    = textureGatherOffsets(sampler, texCoords, offsets, 1);\n"
    251 	"    with_offset_2    = textureGatherOffsets(sampler, texCoords, offsets, 2);\n"
    252 	"    with_offset_3    = textureGatherOffsets(sampler, texCoords, offsets, 3);\n"
    253 	"}\n";
    254 
    255 /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest */
    256 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::m_vertex_shader_code =
    257 	"${VERSION}\n"
    258 	"\n"
    259 	"${GPU_SHADER5_REQUIRE}\n"
    260 	"\n"
    261 	"precision highp float;\n"
    262 	"precision highp sampler2DShadow;\n"
    263 	"\n"
    264 	"uniform sampler2DShadow sampler;\n"
    265 	"\n"
    266 	"in ivec2 offsets;\n"
    267 	"in vec2  texCoords;\n"
    268 	"\n"
    269 	"flat out ivec4 with_offset;\n"
    270 	"flat out ivec4 without_offset;\n"
    271 	"\n"
    272 	"void main()\n"
    273 	"{\n"
    274 	"    ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n"
    275 	"    float step         = 1.0f / float(texture_size.x);\n"
    276 	"\n"
    277 	"    without_offset = ivec4(0, 0, 0, 0);\n"
    278 	"    with_offset    = ivec4(0, 0, 0, 0);\n"
    279 	"\n"
    280 	"    for (int x = 0; x < texture_size.x; ++x)\n"
    281 	"    {\n"
    282 	"        float refZ = float(x) * step;\n"
    283 	"\n"
    284 	"        without_offset += ivec4(textureGather      (sampler, texCoords, refZ));\n"
    285 	"        with_offset    += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n"
    286 	"    }\n"
    287 	"}\n";
    288 
    289 /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest */
    290 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::m_vertex_shader_code =
    291 	"${VERSION}\n"
    292 	"\n"
    293 	"${GPU_SHADER5_REQUIRE}\n"
    294 	"\n"
    295 	"precision highp float;\n"
    296 	"precision highp sampler2DShadow;\n"
    297 	"\n"
    298 	"uniform sampler2DShadow sampler;\n"
    299 	"\n"
    300 	"in ivec2 offsets;\n"
    301 	"in vec2  texCoords;\n"
    302 	"\n"
    303 	"flat out ivec4 without_offset;\n"
    304 	"flat out ivec4 with_offset;\n"
    305 	"\n"
    306 	"void main()\n"
    307 	"{\n"
    308 	"    ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n"
    309 	"    float step         = 1.0f / float(texture_size.y);\n"
    310 	"\n"
    311 	"    without_offset = ivec4(0, 0, 0, 0);\n"
    312 	"    with_offset    = ivec4(0, 0, 0, 0);\n"
    313 	"\n"
    314 	"    for (int y = 0; y < texture_size.y; ++y)\n"
    315 	"    {\n"
    316 	"        float refZ = float(y) * step;\n"
    317 	"\n"
    318 	"        without_offset += ivec4(textureGather      (sampler, texCoords, refZ));\n"
    319 	"        with_offset    += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n"
    320 	"    }\n"
    321 	"}\n";
    322 
    323 /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DArrayCaseTest */
    324 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::m_vertex_shader_code =
    325 	"${VERSION}\n"
    326 	"\n"
    327 	"${GPU_SHADER5_REQUIRE}\n"
    328 	"\n"
    329 	"precision highp float;\n"
    330 	"precision highp sampler2DArrayShadow;\n"
    331 	"\n"
    332 	"uniform sampler2DArrayShadow sampler;\n"
    333 	"\n"
    334 	"in ivec2 offsets;\n"
    335 	"in vec3  texCoords;\n"
    336 	"\n"
    337 	"flat out ivec4 without_offset;\n"
    338 	"flat out ivec4 with_offset;\n"
    339 	"\n"
    340 	"void main()\n"
    341 	"{\n"
    342 	"    ivec3 texture_size = textureSize(sampler, 0 /* lod */);\n"
    343 	"    float step         = 1.0f / float(texture_size.x);\n"
    344 	"\n"
    345 	"    without_offset = ivec4(0, 0, 0, 0);\n"
    346 	"    with_offset    = ivec4(0, 0, 0, 0);\n"
    347 	"\n"
    348 	"    for (int x = 0; x < texture_size.x; ++x)\n"
    349 	"    {\n"
    350 	"        float refZ = float(x) * step;\n"
    351 	"\n"
    352 	"        without_offset += ivec4(textureGather      (sampler, texCoords, refZ));\n"
    353 	"        with_offset    += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n"
    354 	"    }\n"
    355 	"}\n";
    356 
    357 /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest */
    358 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::m_vertex_shader_code =
    359 	"${VERSION}\n"
    360 	"\n"
    361 	"${GPU_SHADER5_REQUIRE}\n"
    362 	"\n"
    363 	"precision highp float;\n"
    364 	"precision highp sampler2DShadow;\n"
    365 	"\n"
    366 	"uniform sampler2DShadow sampler;\n"
    367 	"\n"
    368 	"in ivec2 offsets;\n"
    369 	"in vec2  texCoords;\n"
    370 	"\n"
    371 	"flat out ivec4 with_offset;\n"
    372 	"flat out ivec4 without_offset;\n"
    373 	"flat out ivec4 floor_tex_coord;\n"
    374 	"\n"
    375 	"void main()\n"
    376 	"{\n"
    377 	"    ivec2 texture_size  = textureSize(sampler, 0 /* lod */);\n"
    378 	"    float step          = 1.0f / float(texture_size.x);\n"
    379 	"\n"
    380 	"    vec2 floorTexCoords = floor(texCoords);\n"
    381 	"    vec2 fractTexCoords = texCoords - floorTexCoords;\n"
    382 	"\n"
    383 	"    floor_tex_coord     = ivec4(ivec2(floorTexCoords.xy), 0, 0);\n"
    384 	"\n"
    385 	"    without_offset      = ivec4(0, 0, 0, 0);\n"
    386 	"    with_offset         = ivec4(0, 0, 0, 0);\n"
    387 	"\n"
    388 	"    for (int x = 0; x < texture_size.x; ++x)\n"
    389 	"    {\n"
    390 	"        float refZ = float(x) * step;\n"
    391 	"\n"
    392 	"        without_offset += ivec4(textureGather      (sampler, fractTexCoords, refZ));\n"
    393 	"        with_offset    += ivec4(textureGatherOffset(sampler, texCoords,      refZ, offsets));\n"
    394 	"    }\n"
    395 	"}\n";
    396 
    397 /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest */
    398 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::m_vertex_shader_code =
    399 	"${VERSION}\n"
    400 	"\n"
    401 	"${GPU_SHADER5_REQUIRE}\n"
    402 	"\n"
    403 	"precision highp float;\n"
    404 	"precision highp sampler2DShadow;\n"
    405 	"\n"
    406 	"uniform sampler2DShadow sampler;\n"
    407 	"uniform sampler2DShadow reference_sampler;\n"
    408 	"\n"
    409 	"in ivec2 offsets;\n"
    410 	"in vec2  texCoords;\n"
    411 	"\n"
    412 	"flat out ivec4 with_offset;\n"
    413 	"flat out ivec4 without_offset;\n"
    414 	"flat out ivec4 floor_tex_coord;\n"
    415 	"\n"
    416 	"void main()\n"
    417 	"{\n"
    418 	"    ivec2 texture_size  = textureSize(sampler, 0 /* lod */);\n"
    419 	"    float step          = 1.0f / float(texture_size.x);\n"
    420 	"\n"
    421 	"    vec2 floorTexCoords = floor(texCoords);\n"
    422 	"    vec2 fractTexCoords = texCoords - floorTexCoords;\n"
    423 	"\n"
    424 	"    floor_tex_coord     = ivec4(ivec2(floorTexCoords.xy), 0, 0);\n"
    425 	"\n"
    426 	"    without_offset      = ivec4(0, 0, 0, 0);\n"
    427 	"    with_offset         = ivec4(0, 0, 0, 0);\n"
    428 	"\n"
    429 	"    for (int x = 0; x < texture_size.x; ++x)\n"
    430 	"    {\n"
    431 	"        float refZ = float(x) * step;\n"
    432 	"\n"
    433 	"        without_offset += ivec4(textureGather      (reference_sampler, fractTexCoords, refZ));\n"
    434 	"        with_offset    += ivec4(textureGatherOffset(sampler,           texCoords,      refZ, offsets));\n"
    435 	"    }\n"
    436 	"}\n";
    437 
    438 /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest */
    439 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::m_vertex_shader_code_preamble =
    440 	"${VERSION}\n"
    441 	"\n"
    442 	"${GPU_SHADER5_REQUIRE}\n"
    443 	"\n"
    444 	"precision highp float;\n"
    445 	"precision highp sampler2DShadow;\n"
    446 	"\n"
    447 	"uniform sampler2DShadow sampler;\n"
    448 	"\n"
    449 	"in vec2  texCoords;\n"
    450 	"\n"
    451 	"flat out ivec4 without_offset;\n"
    452 	"flat out ivec4 with_offset;\n"
    453 	"\n"
    454 	"void main()\n"
    455 	"{\n"
    456 	"    const ivec2 offsets[4] =\n";
    457 
    458 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::m_vertex_shader_code_body =
    459 	"\n"
    460 	"    ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n"
    461 	"    float step         = 1.0f / float(texture_size.x);\n"
    462 	"\n"
    463 	"    without_offset = ivec4(0, 0, 0, 0);\n"
    464 	"    with_offset = ivec4(0, 0, 0, 0);\n"
    465 	"\n"
    466 	"    for (int x = 0; x < texture_size.x; ++x)\n"
    467 	"    {\n"
    468 	"        float refZ = float(x) * step;\n"
    469 	"\n"
    470 	"        without_offset += ivec4(textureGather       (sampler, texCoords, refZ));\n"
    471 	"        with_offset    += ivec4(textureGatherOffsets(sampler, texCoords, refZ, offsets));\n"
    472 	"    }\n"
    473 	"}\n";
    474 
    475 /* Constants for GPUShader5TextureGatherOffsetTestBase */
    476 const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_coordinates_attribute_name	 = "texCoords";
    477 const int				 GPUShader5TextureGatherOffsetTestBase::m_coordinate_resolution			 = 1024;
    478 const int				 GPUShader5TextureGatherOffsetTestBase::m_max_coordinate_value			 = 8;
    479 const int				 GPUShader5TextureGatherOffsetTestBase::m_min_coordinate_value			 = -8;
    480 const unsigned int		 GPUShader5TextureGatherOffsetTestBase::m_n_components_per_varying		 = 4;
    481 const unsigned int		 GPUShader5TextureGatherOffsetTestBase::m_n_texture_array_length		 = 4;
    482 const unsigned int		 GPUShader5TextureGatherOffsetTestBase::m_n_vertices					 = 128;
    483 const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_sampler_uniform_name			 = "sampler";
    484 const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_reference_sampler_uniform_name = "reference_sampler";
    485 
    486 /* Constants for GPUShader5TextureGatherOffsetColorTestBase */
    487 const unsigned int GPUShader5TextureGatherOffsetColorTestBase::m_texture_size = 64;
    488 
    489 /* Constants for GPUShader5TextureGatherOffsetDepthTestBase */
    490 const unsigned int GPUShader5TextureGatherOffsetDepthTestBase::m_texture_size = 64;
    491 
    492 /* Constants for GPUShader5TextureGatherOffsetColor2DRepeatCaseTest */
    493 const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::m_offsets_attribute_name = "offsets";
    494 const unsigned int		 GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::m_n_offsets_components   = 2;
    495 
    496 /* Constants for GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest */
    497 const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::m_offsets_attribute_name = "offsets";
    498 const unsigned int		 GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::m_n_offsets_components   = 2;
    499 
    500 /** Constructor
    501  *
    502  *  @param context       Test context
    503  *  @param name          Test case's name
    504  *  @param description   Test case's description
    505  **/
    506 GPUShader5TextureGatherOffsetTestBase::GPUShader5TextureGatherOffsetTestBase(Context&			  context,
    507 																			 const ExtParameters& extParams,
    508 																			 const char* name, const char* description)
    509 	: TestCaseBase(context, extParams, name, description)
    510 	, m_min_texture_gather_offset(0)
    511 	, m_max_texture_gather_offset(0)
    512 	, m_fragment_shader_id(0)
    513 	, m_program_object_id(0)
    514 	, m_vertex_shader_id(0)
    515 	, m_vertex_array_object_id(0)
    516 	, m_texture_object_id(0)
    517 	, m_sampler_object_id(0)
    518 	, m_is_texture_array(0)
    519 	, m_texture_bytes_per_pixel(0)
    520 	, m_texture_format(0)
    521 	, m_texture_internal_format(0)
    522 	, m_texture_type(0)
    523 	, m_texture_size(0)
    524 	, m_texture_wrap_mode(0)
    525 	, m_transform_feedback_buffer_size(0)
    526 	, m_transform_feedback_buffer_object_id(0)
    527 	, m_n_coordinates_components(0)
    528 {
    529 	/* Nothing to be done here */
    530 }
    531 
    532 /** Deinitializes GLES objects created during the test.
    533  *
    534  */
    535 void GPUShader5TextureGatherOffsetTestBase::deinit()
    536 {
    537 	/* GL */
    538 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
    539 
    540 	/* Bind default values */
    541 	gl.useProgram(0);
    542 	gl.bindVertexArray(0);
    543 	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* offset */, 0 /* id */);
    544 	gl.bindBuffer(GL_ARRAY_BUFFER, 0);
    545 
    546 	/* Delete everything */
    547 	if (0 != m_vertex_array_object_id)
    548 	{
    549 		gl.deleteVertexArrays(1, &m_vertex_array_object_id);
    550 
    551 		m_vertex_array_object_id = 0;
    552 	}
    553 
    554 	if (0 != m_transform_feedback_buffer_object_id)
    555 	{
    556 		gl.deleteBuffers(1, &m_transform_feedback_buffer_object_id);
    557 
    558 		m_transform_feedback_buffer_object_id = 0;
    559 	}
    560 
    561 	if (false == m_vertex_buffer_ids.empty())
    562 	{
    563 		gl.deleteBuffers((glw::GLsizei)m_vertex_buffer_ids.size(), &m_vertex_buffer_ids[0]);
    564 	}
    565 
    566 	if (0 != m_program_object_id)
    567 	{
    568 		gl.deleteProgram(m_program_object_id);
    569 
    570 		m_program_object_id = 0;
    571 	}
    572 
    573 	if (0 != m_fragment_shader_id)
    574 	{
    575 		gl.deleteShader(m_fragment_shader_id);
    576 
    577 		m_fragment_shader_id = 0;
    578 	}
    579 
    580 	if (0 != m_vertex_shader_id)
    581 	{
    582 		gl.deleteShader(m_vertex_shader_id);
    583 
    584 		m_vertex_shader_id = 0;
    585 	}
    586 
    587 	if (0 != m_texture_object_id)
    588 	{
    589 		gl.deleteTextures(1, &m_texture_object_id);
    590 
    591 		m_texture_object_id = 0;
    592 	}
    593 
    594 	if (0 != m_sampler_object_id)
    595 	{
    596 		gl.deleteSamplers(1, &m_sampler_object_id);
    597 
    598 		m_sampler_object_id = 0;
    599 	}
    600 
    601 	/* Deinitialize base */
    602 	TestCaseBase::deinit();
    603 }
    604 
    605 /** Initializes GLES objects used during the test.
    606  *
    607  */
    608 void GPUShader5TextureGatherOffsetTestBase::initTest()
    609 {
    610 	/* This test should only run if EXT_gpu_shader5 is supported */
    611 	if (true != m_is_gpu_shader5_supported)
    612 	{
    613 		throw tcu::NotSupportedError(GPU_SHADER5_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
    614 	}
    615 
    616 	/* GL */
    617 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
    618 
    619 	/* Get minimum and maximum texture gather offsets */
    620 	gl.getIntegerv(GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET, &m_min_texture_gather_offset);
    621 	gl.getIntegerv(GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET, &m_max_texture_gather_offset);
    622 
    623 	GLU_EXPECT_NO_ERROR(
    624 		gl.getError(),
    625 		"Failed to get value of GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET or GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET");
    626 
    627 	/* Get details for transform feedback from child class */
    628 	getTransformFeedBackDetails(m_transform_feedback_buffer_size, m_captured_varying_names);
    629 
    630 	/* Get shaders' code from children class */
    631 	getShaderParts(m_vertex_shader_parts);
    632 
    633 	/* Create program and shaders */
    634 	m_program_object_id = gl.createProgram();
    635 
    636 	m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER);
    637 	m_vertex_shader_id   = gl.createShader(GL_VERTEX_SHADER);
    638 
    639 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create program or shader object(s)");
    640 
    641 	/* Set up transform feedback */
    642 	gl.transformFeedbackVaryings(m_program_object_id, (glw::GLsizei)m_captured_varying_names.size(),
    643 								 &m_captured_varying_names[0], GL_INTERLEAVED_ATTRIBS);
    644 
    645 	GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed");
    646 
    647 	/* Build program */
    648 	if (false == buildProgram(m_program_object_id, m_fragment_shader_id, 1 /* number of FS parts */,
    649 							  &m_fragment_shader_code, m_vertex_shader_id, (unsigned int)m_vertex_shader_parts.size(),
    650 							  &m_vertex_shader_parts[0]))
    651 	{
    652 		TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader");
    653 	}
    654 
    655 	/* Set program as active */
    656 	gl.useProgram(m_program_object_id);
    657 	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed");
    658 
    659 	/* Generate and bind VAO */
    660 	gl.genVertexArrays(1, &m_vertex_array_object_id);
    661 	gl.bindVertexArray(m_vertex_array_object_id);
    662 
    663 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create vertex array object");
    664 
    665 	/* Generate, bind and allocate buffer */
    666 	gl.genBuffers(1, &m_transform_feedback_buffer_object_id);
    667 	gl.bindBuffer(GL_ARRAY_BUFFER, m_transform_feedback_buffer_object_id);
    668 	gl.bufferData(GL_ARRAY_BUFFER, m_transform_feedback_buffer_size, 0 /* no start data */, GL_STATIC_DRAW);
    669 
    670 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create buffer object");
    671 
    672 	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_transform_feedback_buffer_object_id);
    673 	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed");
    674 
    675 	/* Create and fill texture */
    676 	prepareTexture();
    677 
    678 	/* Let inheriting class prepare test specific input for program */
    679 	prepareProgramInput();
    680 }
    681 
    682 /** Executes the test.
    683  *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
    684  *
    685  *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
    686  *
    687  *  Note the function throws exception should an error occur!
    688  **/
    689 tcu::TestCase::IterateResult GPUShader5TextureGatherOffsetTestBase::iterate()
    690 {
    691 	initTest();
    692 
    693 	/* Retrieve ES entrypoints */
    694 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
    695 
    696 	/* Verification result */
    697 	bool result = false;
    698 
    699 	/* Setup transform feedback */
    700 	gl.enable(GL_RASTERIZER_DISCARD);
    701 	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_RASTERIZER_DISCARD) call failed");
    702 
    703 	gl.beginTransformFeedback(GL_POINTS);
    704 	GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed");
    705 	{
    706 		/* Draw */
    707 		gl.drawArrays(GL_POINTS, 0 /* first */, m_n_vertices);
    708 
    709 		GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed");
    710 	}
    711 	/* Stop transform feedback */
    712 	gl.endTransformFeedback();
    713 	GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed");
    714 
    715 	gl.disable(GL_RASTERIZER_DISCARD);
    716 	GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable(GL_RASTERIZER_DISCARD) call failed");
    717 
    718 	/* Map transfrom feedback results */
    719 	const void* transform_feedback_data = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* offset */,
    720 															m_transform_feedback_buffer_size, GL_MAP_READ_BIT);
    721 
    722 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not map the buffer object into process space");
    723 
    724 	/* Verify data extracted from transfrom feedback */
    725 	result = verifyResult(transform_feedback_data);
    726 
    727 	/* Unmap transform feedback buffer */
    728 	gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
    729 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error unmapping the buffer object");
    730 
    731 	/* Verify results */
    732 	if (true != result)
    733 	{
    734 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    735 	}
    736 	else
    737 	{
    738 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    739 	}
    740 
    741 	return STOP;
    742 }
    743 
    744 /** Logs array of ints
    745  *  Format: description ( e1 e2 ... eN )
    746  *
    747  *  @param data        Array of ints
    748  *  @param length      Number of elements to log
    749  *  @param description Description string
    750  **/
    751 void GPUShader5TextureGatherOffsetTestBase::logArray(const glw::GLint* data, unsigned int length,
    752 													 const char* description)
    753 {
    754 	/* Message object */
    755 	tcu::MessageBuilder message = m_testCtx.getLog() << tcu::TestLog::Message;
    756 
    757 	/* Adds description */
    758 	message << description;
    759 
    760 	/* Begin array */
    761 	message << "( ";
    762 
    763 	/* For each varying */
    764 	for (unsigned int i = 0; i < length; ++i)
    765 	{
    766 		message << data[i] << " ";
    767 	}
    768 
    769 	/* End array */
    770 	message << ") ";
    771 
    772 	message << tcu::TestLog::EndMessage;
    773 }
    774 
    775 /** Logs coordinates for vertex at given index
    776  *  Format: Texture coordinates (range [0:1]): [x, y, .. ]
    777  *
    778  *  @param index Index of vertex
    779  **/
    780 void GPUShader5TextureGatherOffsetTestBase::logCoordinates(unsigned int index)
    781 {
    782 	/* Message object */
    783 	tcu::MessageBuilder message = m_testCtx.getLog() << tcu::TestLog::Message;
    784 
    785 	/* Begin array */
    786 	message << "Texture coordinates (range [0:1]): [";
    787 
    788 	/* Component index */
    789 	unsigned int i = 0;
    790 
    791 	while (1)
    792 	{
    793 		message << m_coordinates_buffer_data[index * m_n_coordinates_components + i];
    794 
    795 		i += 1;
    796 
    797 		if (i >= m_n_coordinates_components)
    798 		{
    799 			break;
    800 		}
    801 		else
    802 		{
    803 			message << ", ";
    804 		}
    805 	}
    806 
    807 	/* End array */
    808 	message << "]" << tcu::TestLog::EndMessage;
    809 }
    810 
    811 /** Prepare buffers for vertex attributes
    812  *
    813  **/
    814 void GPUShader5TextureGatherOffsetTestBase::prepareProgramInput()
    815 {
    816 	/* GL */
    817 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
    818 
    819 	/* Get vertex buffer infos from child class */
    820 	prepareVertexBuffersData(m_vertex_buffer_infos);
    821 
    822 	/* Prepare info for coordinates */
    823 	prepareVertexBufferInfoForCoordinates();
    824 
    825 	/* Constant for number of vertex buffers */
    826 	const unsigned int n_vertex_buffers = (const unsigned int)m_vertex_buffer_infos.size();
    827 
    828 	/* Prepare storage for vertex buffer ids */
    829 	m_vertex_buffer_ids.resize(n_vertex_buffers);
    830 
    831 	/* Generate buffers */
    832 	gl.genBuffers(n_vertex_buffers, &m_vertex_buffer_ids[0]);
    833 
    834 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create vertex buffers");
    835 
    836 	/* Setup each vertex buffer */
    837 	for (unsigned int i = 0; i < n_vertex_buffers; ++i)
    838 	{
    839 		/* References for i-th vertex buffer */
    840 		glw::GLuint		  vertex_buffer_id   = m_vertex_buffer_ids[i];
    841 		VertexBufferInfo& vertex_buffer_info = m_vertex_buffer_infos[i];
    842 
    843 		/* Get attribute location */
    844 		glw::GLint attribute_location =
    845 			gl.getAttribLocation(m_program_object_id, m_vertex_buffer_infos[i].attribute_name);
    846 
    847 		if ((-1 == attribute_location) || (GL_NO_ERROR != gl.getError()))
    848 		{
    849 			TCU_FAIL("Failed to get location of attribute");
    850 		}
    851 
    852 		/* Setup buffer for offsets attribute */
    853 		gl.bindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id);
    854 		gl.bufferData(GL_ARRAY_BUFFER, vertex_buffer_info.data_size, vertex_buffer_info.data, GL_STATIC_DRAW);
    855 
    856 		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to fill vertex buffer with data");
    857 
    858 		/* Setup attribute */
    859 		gl.enableVertexAttribArray(attribute_location);
    860 
    861 		if (GL_INT == vertex_buffer_info.type)
    862 		{
    863 			gl.vertexAttribIPointer(attribute_location, vertex_buffer_info.n_components, vertex_buffer_info.type,
    864 									0 /* stride */, 0 /* offset */);
    865 		}
    866 		else
    867 		{
    868 			gl.vertexAttribPointer(attribute_location, vertex_buffer_info.n_components, vertex_buffer_info.type,
    869 								   GL_FALSE /* normalization */, 0 /* stride */, 0 /* offset */);
    870 		}
    871 
    872 		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup vertex attribute arrays");
    873 	}
    874 
    875 	/* Get sampler location */
    876 	glw::GLint sampler_location = gl.getUniformLocation(m_program_object_id, m_sampler_uniform_name);
    877 
    878 	if ((-1 == sampler_location) || (GL_NO_ERROR != gl.getError()))
    879 	{
    880 		TCU_FAIL("Failed to get location of uniform \"sampler\"");
    881 	}
    882 
    883 	/* Set uniform at sampler location value to index of first texture unit */
    884 	gl.uniform1i(sampler_location, 0 /* first texture unit */);
    885 	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set uniform value");
    886 
    887 	if (GL_CLAMP_TO_EDGE == m_texture_wrap_mode)
    888 	{
    889 		/* Get reference_sampler location */
    890 		glw::GLint reference_sampler_location =
    891 			gl.getUniformLocation(m_program_object_id, m_reference_sampler_uniform_name);
    892 
    893 		if ((-1 == reference_sampler_location) || (GL_NO_ERROR != gl.getError()))
    894 		{
    895 			TCU_FAIL("Failed to get location of uniform \"reference sampler\"");
    896 		}
    897 
    898 		/* Set uniform at reference_sampler location value to index of second texture unit */
    899 		gl.uniform1i(reference_sampler_location, 1 /* second texture unit */);
    900 		GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set uniform value");
    901 	}
    902 }
    903 
    904 /** Prepare texture and bind it to sampler
    905  *
    906  **/
    907 void GPUShader5TextureGatherOffsetTestBase::prepareTexture()
    908 {
    909 	/* Retrieve ES entrypoints */
    910 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
    911 
    912 	/* Get texture info from child class */
    913 	getTextureInfo(m_texture_size, m_texture_internal_format, m_texture_format, m_texture_type,
    914 				   m_texture_bytes_per_pixel);
    915 
    916 	isTextureArray(m_is_texture_array);
    917 	getTextureWrapMode(m_texture_wrap_mode);
    918 
    919 	/* Verify that recieved texture parameters are valid */
    920 	glw::GLint max_texture_size = 0;
    921 
    922 	gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
    923 	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TEXTURE_SIZE pname");
    924 
    925 	if (m_texture_size > (glw::GLuint)max_texture_size)
    926 	{
    927 		throw tcu::NotSupportedError("Required texture dimmensions exceeds GL_MAX_TEXTURE_SIZE limit", "", __FILE__,
    928 									 __LINE__);
    929 	}
    930 
    931 	/* Activate first texture unit */
    932 	gl.activeTexture(GL_TEXTURE0);
    933 	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture(GL_TEXTURE0) failed");
    934 
    935 	/* Generate and allocate texture */
    936 	gl.genTextures(1, &m_texture_object_id);
    937 	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed");
    938 
    939 	if (true == m_is_texture_array)
    940 	{
    941 		gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texture_object_id);
    942 		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed");
    943 
    944 		gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1 /* levels */, m_texture_internal_format, m_texture_size, m_texture_size,
    945 						m_n_texture_array_length);
    946 		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage3D() call failed");
    947 	}
    948 	else
    949 	{
    950 		gl.bindTexture(GL_TEXTURE_2D, m_texture_object_id);
    951 		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed");
    952 
    953 		gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, m_texture_internal_format, m_texture_size, m_texture_size);
    954 		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed");
    955 	}
    956 
    957 	/* Storage for texture data */
    958 	std::vector<glw::GLubyte> texture_data;
    959 
    960 	texture_data.resize(m_texture_size * m_texture_size * m_texture_bytes_per_pixel);
    961 
    962 	/* Let child class prepare data for texture */
    963 	prepareTextureData(&texture_data[0]);
    964 
    965 	/* Update texture data */
    966 	if (true == m_is_texture_array)
    967 	{
    968 		for (unsigned int z = 0; z < m_n_texture_array_length; ++z)
    969 		{
    970 			gl.texSubImage3D(GL_TEXTURE_2D_ARRAY, 0 /* level */, 0 /* x */, 0 /* y */, z, m_texture_size,
    971 							 m_texture_size, 1 /* depth */, m_texture_format, m_texture_type, &texture_data[0]);
    972 
    973 			GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update texture data");
    974 		}
    975 	}
    976 	else
    977 	{
    978 		gl.texSubImage2D(GL_TEXTURE_2D, 0 /* level */, 0 /* x */, 0 /* y */, m_texture_size, m_texture_size,
    979 						 m_texture_format, m_texture_type, &texture_data[0]);
    980 
    981 		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update texture data");
    982 	}
    983 
    984 	/* Set shadow comparison, filtering and wrap modes */
    985 	glw::GLenum texture_target;
    986 
    987 	if (true == m_is_texture_array)
    988 	{
    989 		texture_target = GL_TEXTURE_2D_ARRAY;
    990 	}
    991 	else
    992 	{
    993 		texture_target = GL_TEXTURE_2D;
    994 	}
    995 
    996 	/* Storage for border color */
    997 	glw::GLfloat color[4];
    998 
    999 	/* Get border color */
   1000 	getBorderColor(color);
   1001 
   1002 	gl.texParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   1003 	gl.texParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   1004 	gl.texParameteri(texture_target, GL_TEXTURE_WRAP_S, m_texture_wrap_mode);
   1005 	gl.texParameteri(texture_target, GL_TEXTURE_WRAP_T, m_texture_wrap_mode);
   1006 	gl.texParameteri(texture_target, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
   1007 	gl.texParameteri(texture_target, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
   1008 
   1009 	/* Set border color when "clamp to border" mode is selected */
   1010 	if (m_glExtTokens.CLAMP_TO_BORDER == m_texture_wrap_mode)
   1011 	{
   1012 		gl.texParameterfv(texture_target, m_glExtTokens.TEXTURE_BORDER_COLOR, color);
   1013 	}
   1014 
   1015 	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set texture parameters");
   1016 
   1017 	/* Setup texture unit for reference_sampler */
   1018 	if (GL_CLAMP_TO_EDGE == m_texture_wrap_mode)
   1019 	{
   1020 		/* Activate second texture unit */
   1021 		gl.activeTexture(GL_TEXTURE1);
   1022 		GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture(GL_TEXTURE1) failed");
   1023 
   1024 		/* Bind texture */
   1025 		gl.bindTexture(texture_target, m_texture_object_id);
   1026 		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture failed");
   1027 
   1028 		/* Generate sampler */
   1029 		gl.genSamplers(1, &m_sampler_object_id);
   1030 		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to generate sampler");
   1031 
   1032 		/* Bind sampler to second texture unit */
   1033 		gl.bindSampler(1, m_sampler_object_id);
   1034 		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind sampler to unit 1");
   1035 
   1036 		/* Set sampler parameters */
   1037 		gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   1038 		gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   1039 		gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_WRAP_S, m_glExtTokens.CLAMP_TO_BORDER);
   1040 		gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_WRAP_T, m_glExtTokens.CLAMP_TO_BORDER);
   1041 		gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
   1042 		gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
   1043 		gl.samplerParameterfv(m_sampler_object_id, m_glExtTokens.TEXTURE_BORDER_COLOR, color);
   1044 
   1045 		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set sampler parameters");
   1046 	}
   1047 }
   1048 
   1049 /** Prepare buffer for texture coordinates
   1050  *
   1051  **/
   1052 void GPUShader5TextureGatherOffsetTestBase::prepareVertexBufferInfoForCoordinates()
   1053 {
   1054 	/* Select proper number of components */
   1055 	if (true == m_is_texture_array)
   1056 	{
   1057 		m_n_coordinates_components = 3;
   1058 	}
   1059 	else
   1060 	{
   1061 		m_n_coordinates_components = 2;
   1062 	}
   1063 
   1064 	/* Prepare storage for texture coordinates */
   1065 	m_coordinates_buffer_data.resize(m_n_vertices * m_n_coordinates_components);
   1066 
   1067 	/* Variables for calculation of texture coordiantes' range and offsets */
   1068 	const float coordinate_denominator = m_coordinate_resolution;
   1069 	int			x_modulus;
   1070 	float		x_offset;
   1071 	float		x_range;
   1072 	int			y_modulus;
   1073 	float		y_offset;
   1074 	float		y_range;
   1075 
   1076 	/* Calculation of texture coordiantes' range and offsets */
   1077 	x_range = m_max_coordinate_value - m_min_coordinate_value;
   1078 	y_range = m_max_coordinate_value - m_min_coordinate_value;
   1079 
   1080 	x_offset = m_min_coordinate_value;
   1081 	y_offset = m_min_coordinate_value;
   1082 
   1083 	x_range *= coordinate_denominator;
   1084 	y_range *= coordinate_denominator;
   1085 
   1086 	x_modulus = (int)x_range;
   1087 	y_modulus = (int)y_range;
   1088 
   1089 	/* Prepare texture coordinates */
   1090 	if (true == m_is_texture_array)
   1091 	{
   1092 		/* First four coordinates are corners, each comes from unique level */
   1093 		setCoordinatesData(0.0f, 0.0f, 0.0f, 0);
   1094 		setCoordinatesData(0.0f, 1.0f, 1.0f, 1);
   1095 		setCoordinatesData(1.0f, 0.0f, 2.0f, 2);
   1096 		setCoordinatesData(1.0f, 1.0f, 3.0f, 3);
   1097 
   1098 		/* Generate rest of texture coordinates */
   1099 		for (unsigned int i = 4; i < m_n_vertices; ++i)
   1100 		{
   1101 			const glw::GLfloat coord_x = ((float)(rand() % x_modulus)) / coordinate_denominator + x_offset;
   1102 			const glw::GLfloat coord_y = ((float)(rand() % y_modulus)) / coordinate_denominator + y_offset;
   1103 			const glw::GLfloat coord_z =
   1104 				((float)(rand() % m_n_texture_array_length * m_coordinate_resolution)) / coordinate_denominator;
   1105 
   1106 			setCoordinatesData(coord_x, coord_y, coord_z, i);
   1107 		}
   1108 	}
   1109 	else
   1110 	{
   1111 		/* First four coordinates are corners */
   1112 		setCoordinatesData(0.0f, 0.0f, 0);
   1113 		setCoordinatesData(0.0f, 1.0f, 1);
   1114 		setCoordinatesData(1.0f, 0.0f, 2);
   1115 		setCoordinatesData(1.0f, 1.0f, 3);
   1116 
   1117 		/* Generate rest of texture coordinates */
   1118 		for (unsigned int i = 4; i < m_n_vertices; ++i)
   1119 		{
   1120 			const glw::GLfloat coord_x = ((float)(rand() % x_modulus)) / coordinate_denominator + x_offset;
   1121 			const glw::GLfloat coord_y = ((float)(rand() % y_modulus)) / coordinate_denominator + y_offset;
   1122 
   1123 			setCoordinatesData(coord_x, coord_y, i);
   1124 		}
   1125 	}
   1126 
   1127 	/* Setup coordinates VB info */
   1128 	VertexBufferInfo info;
   1129 
   1130 	info.attribute_name = m_coordinates_attribute_name;
   1131 	info.n_components   = m_n_coordinates_components;
   1132 	info.type			= GL_FLOAT;
   1133 	info.data			= &m_coordinates_buffer_data[0];
   1134 	info.data_size		= (glw::GLuint)(m_coordinates_buffer_data.size() * sizeof(glw::GLfloat));
   1135 
   1136 	/* Store results */
   1137 	m_vertex_buffer_infos.push_back(info);
   1138 }
   1139 
   1140 /** Set 2D texture coordinate for vertex at given index
   1141  *
   1142  *  @param x     X coordinate
   1143  *  @param y     Y coordinate
   1144  *  @param index Index of vertex
   1145  **/
   1146 void GPUShader5TextureGatherOffsetTestBase::setCoordinatesData(glw::GLfloat x, glw::GLfloat y, unsigned int index)
   1147 {
   1148 	const unsigned int vertex_offset = m_n_coordinates_components * index;
   1149 
   1150 	m_coordinates_buffer_data[vertex_offset + 0] = x;
   1151 	m_coordinates_buffer_data[vertex_offset + 1] = y;
   1152 }
   1153 
   1154 /** Set 3D texture coordinate for vertex at given index
   1155  *
   1156  *  @param x     X coordinate
   1157  *  @param y     Y coordinate
   1158  *  @param z     Z coordinate
   1159  *  @param index Index of vertex
   1160  **/
   1161 void GPUShader5TextureGatherOffsetTestBase::setCoordinatesData(glw::GLfloat x, glw::GLfloat y, glw::GLfloat z,
   1162 															   unsigned int index)
   1163 {
   1164 	const unsigned int vertex_offset = m_n_coordinates_components * index;
   1165 
   1166 	m_coordinates_buffer_data[vertex_offset + 0] = x;
   1167 	m_coordinates_buffer_data[vertex_offset + 1] = y;
   1168 	m_coordinates_buffer_data[vertex_offset + 2] = z;
   1169 }
   1170 
   1171 /** Constructor
   1172  *
   1173  * @param context       Test context
   1174  * @param name          Test case's name
   1175  * @param description   Test case's description
   1176  **/
   1177 GPUShader5TextureGatherOffsetColorTestBase::GPUShader5TextureGatherOffsetColorTestBase(Context&				context,
   1178 																					   const ExtParameters& extParams,
   1179 																					   const char*			name,
   1180 																					   const char*			description)
   1181 	: GPUShader5TextureGatherOffsetTestBase(context, extParams, name, description), m_n_varyings_per_vertex(0)
   1182 {
   1183 	/* Nothing to be done here */
   1184 }
   1185 
   1186 /** Provides color that will be used as border color for "clamp to border" mode
   1187  *
   1188  * @param out_color Color
   1189  **/
   1190 void GPUShader5TextureGatherOffsetColorTestBase::getBorderColor(glw::GLfloat out_color[4])
   1191 {
   1192 	out_color[0] = -1.0f;
   1193 	out_color[1] = -1.0f;
   1194 	out_color[2] = -1.0f;
   1195 	out_color[3] = -1.0f;
   1196 }
   1197 
   1198 /** Provides informations required to create texture
   1199  *
   1200  *  @param out_size                    Size of texture
   1201  *  @param out_texture_internal_format Internal format of texture
   1202  *  @param out_texture_format          Format of texture
   1203  *  @param out_texture_type            Type of texture
   1204  *  @param out_bytes_per_pixel         Bytes per pixel
   1205  **/
   1206 void GPUShader5TextureGatherOffsetColorTestBase::getTextureInfo(glw::GLuint& out_size,
   1207 																glw::GLenum& out_texture_internal_format,
   1208 																glw::GLenum& out_texture_format,
   1209 																glw::GLenum& out_texture_type,
   1210 																glw::GLuint& out_bytes_per_pixel)
   1211 {
   1212 	out_size					= m_texture_size;
   1213 	out_texture_internal_format = GL_RGBA32I;
   1214 	out_texture_format			= GL_RGBA_INTEGER;
   1215 	out_texture_type			= GL_INT;
   1216 	out_bytes_per_pixel			= 4 * sizeof(glw::GLint); /* RGBA * int */
   1217 }
   1218 
   1219 /** Get wrap mode for texture
   1220  *
   1221  *  @param out_wrap_mode Wrap mode
   1222  **/
   1223 void GPUShader5TextureGatherOffsetColorTestBase::getTextureWrapMode(glw::GLenum& out_wrap_mode)
   1224 {
   1225 	out_wrap_mode = GL_REPEAT;
   1226 }
   1227 
   1228 /** Get size of buffer used as output from transform feedback and names of varyings
   1229  *
   1230  *  @param out_buffer_size       Size of buffer
   1231  *  @param out_captured_varyings Names of varyings
   1232  **/
   1233 void GPUShader5TextureGatherOffsetColorTestBase::getTransformFeedBackDetails(
   1234 	glw::GLuint& out_buffer_size, std::vector<const glw::GLchar*>& out_captured_varyings)
   1235 {
   1236 	out_captured_varyings.reserve(8);
   1237 	out_captured_varyings.push_back("without_offset_0");
   1238 	out_captured_varyings.push_back("with_offset_0");
   1239 	out_captured_varyings.push_back("without_offset_1");
   1240 	out_captured_varyings.push_back("with_offset_1");
   1241 	out_captured_varyings.push_back("without_offset_2");
   1242 	out_captured_varyings.push_back("with_offset_2");
   1243 	out_captured_varyings.push_back("without_offset_3");
   1244 	out_captured_varyings.push_back("with_offset_3");
   1245 
   1246 	m_n_varyings_per_vertex = (unsigned int)out_captured_varyings.size();
   1247 
   1248 	out_buffer_size = static_cast<glw::GLuint>(m_n_vertices * m_n_varyings_per_vertex * m_n_components_per_varying *
   1249 											   sizeof(glw::GLint));
   1250 }
   1251 
   1252 /** Check if texture array is required
   1253  *
   1254  *  @param out_is_texture_array Set to true if texture array is required, false otherwise
   1255  **/
   1256 void GPUShader5TextureGatherOffsetColorTestBase::isTextureArray(bool& out_is_texture_array)
   1257 {
   1258 	out_is_texture_array = false;
   1259 }
   1260 
   1261 /** Prepare texture data as expected by all cases in test 9.
   1262  *  Each texel is assigned {x, y, x, y}, where x and y are coordinates of texel.
   1263  *
   1264  *  @param data Storage space for texture data
   1265  **/
   1266 void GPUShader5TextureGatherOffsetColorTestBase::prepareTextureData(glw::GLubyte* data)
   1267 {
   1268 	/* Data pointer */
   1269 	glw::GLint* texture_data = (glw::GLint*)data;
   1270 
   1271 	/* Constants */
   1272 	const unsigned int n_components_per_pixel = 4;
   1273 	const unsigned int line_size			  = n_components_per_pixel * m_texture_size;
   1274 
   1275 	/* Prepare texture's data */
   1276 	for (unsigned int y = 0; y < m_texture_size; ++y)
   1277 	{
   1278 		for (unsigned int x = 0; x < m_texture_size; ++x)
   1279 		{
   1280 			const unsigned int pixel_offset = y * line_size + x * n_components_per_pixel;
   1281 
   1282 			/* texel.r = x, texel.g = y */
   1283 			texture_data[pixel_offset + 0] = x;
   1284 			texture_data[pixel_offset + 1] = y;
   1285 
   1286 			/* texel.b = x, texel.a = y */
   1287 			texture_data[pixel_offset + 2] = x;
   1288 			texture_data[pixel_offset + 3] = y;
   1289 		}
   1290 	}
   1291 }
   1292 
   1293 /** Verification of results
   1294  *
   1295  *  @param result Pointer to data mapped from transform feedback buffer. Size of
   1296  *                data is equal to buffer_size set by getTransformFeedbackBufferSize
   1297  *
   1298  *  @return true  Result match expected value
   1299  *          false Result has wrong value
   1300  **/
   1301 bool GPUShader5TextureGatherOffsetColorTestBase::verifyResult(const void* result_data)
   1302 {
   1303 	/* All data stored in data are ints */
   1304 	glw::GLint* results = (glw::GLint*)result_data;
   1305 
   1306 	/* Verification result */
   1307 	bool result = true;
   1308 
   1309 	/* Constants for data offsets calculation */
   1310 	const unsigned int vertex_size_in_results_buffer = m_n_varyings_per_vertex * m_n_components_per_varying;
   1311 	const unsigned int bytes_per_varying			 = m_n_components_per_varying * sizeof(glw::GLint);
   1312 	const unsigned int vertex_varying_0_offset		 = 0;
   1313 	const unsigned int vertex_varying_1_offset		 = vertex_varying_0_offset + 2 * m_n_components_per_varying;
   1314 	const unsigned int vertex_varying_2_offset		 = vertex_varying_1_offset + 2 * m_n_components_per_varying;
   1315 	const unsigned int vertex_varying_3_offset		 = vertex_varying_2_offset + 2 * m_n_components_per_varying;
   1316 	const unsigned int with_offset_offset			 = m_n_components_per_varying;
   1317 	const unsigned int without_offset_offset		 = 0;
   1318 
   1319 	/* For each vertex */
   1320 	for (unsigned int vertex = 0; vertex < m_n_vertices; ++vertex)
   1321 	{
   1322 		CapturedVaryings captured_data;
   1323 
   1324 		/* Pointers to all varyings for given vertex */
   1325 		const glw::GLint* without_offset_0 =
   1326 			results + vertex_varying_0_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset;
   1327 		const glw::GLint* with_offset_0 =
   1328 			results + vertex_varying_0_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset;
   1329 
   1330 		const glw::GLint* without_offset_1 =
   1331 			results + vertex_varying_1_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset;
   1332 		const glw::GLint* with_offset_1 =
   1333 			results + vertex_varying_1_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset;
   1334 
   1335 		const glw::GLint* without_offset_2 =
   1336 			results + vertex_varying_2_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset;
   1337 		const glw::GLint* with_offset_2 =
   1338 			results + vertex_varying_2_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset;
   1339 
   1340 		const glw::GLint* without_offset_3 =
   1341 			results + vertex_varying_3_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset;
   1342 		const glw::GLint* with_offset_3 =
   1343 			results + vertex_varying_3_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset;
   1344 
   1345 		/* Copy captured varyings to captured_data instance */
   1346 		memcpy(captured_data.without_offset_0, without_offset_0, bytes_per_varying);
   1347 		memcpy(captured_data.without_offset_1, without_offset_1, bytes_per_varying);
   1348 		memcpy(captured_data.without_offset_2, without_offset_2, bytes_per_varying);
   1349 		memcpy(captured_data.without_offset_3, without_offset_3, bytes_per_varying);
   1350 
   1351 		memcpy(captured_data.with_offset_0, with_offset_0, bytes_per_varying);
   1352 		memcpy(captured_data.with_offset_1, with_offset_1, bytes_per_varying);
   1353 		memcpy(captured_data.with_offset_2, with_offset_2, bytes_per_varying);
   1354 		memcpy(captured_data.with_offset_3, with_offset_3, bytes_per_varying);
   1355 
   1356 		/* Let child class check if result is ok */
   1357 		const bool is_result_ok = checkResult(captured_data, vertex, m_texture_size);
   1358 
   1359 		/* Do not break on first error */
   1360 		if (false == is_result_ok)
   1361 		{
   1362 			result = false;
   1363 		}
   1364 	}
   1365 
   1366 	/* Done */
   1367 	return result;
   1368 }
   1369 
   1370 /** Logs data captured varyings
   1371  *
   1372  *  @param varyings Instance of capturedVaryings to be logged
   1373  **/
   1374 void GPUShader5TextureGatherOffsetColorTestBase::logVaryings(const CapturedVaryings& varyings)
   1375 {
   1376 	logArray(varyings.without_offset_0, m_n_components_per_varying, "Without offset X: ");
   1377 
   1378 	logArray(varyings.without_offset_1, m_n_components_per_varying, "Without offset Y: ");
   1379 
   1380 	logArray(varyings.without_offset_2, m_n_components_per_varying, "Without offset Z: ");
   1381 
   1382 	logArray(varyings.without_offset_3, m_n_components_per_varying, "Without offset W: ");
   1383 
   1384 	logArray(varyings.with_offset_0, m_n_components_per_varying, "With offset X: ");
   1385 
   1386 	logArray(varyings.with_offset_1, m_n_components_per_varying, "With offset Y: ");
   1387 
   1388 	logArray(varyings.with_offset_2, m_n_components_per_varying, "With offset Z: ");
   1389 
   1390 	logArray(varyings.with_offset_3, m_n_components_per_varying, "With offset W: ");
   1391 }
   1392 
   1393 /** Constructor
   1394  *
   1395  * @param context       Test context
   1396  * @param name          Test case's name
   1397  * @param description   Test case's description
   1398  **/
   1399 GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::GPUShader5TextureGatherOffsetColor2DRepeatCaseTest(
   1400 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   1401 	: GPUShader5TextureGatherOffsetColorTestBase(context, extParams, name, description)
   1402 {
   1403 	/* Nothing to be done here */
   1404 }
   1405 
   1406 /** Get parts of vertex shader
   1407  *
   1408  *  @param out_vertex_shader_parts Vector of vertex shader parts
   1409  **/
   1410 void GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::getShaderParts(
   1411 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   1412 {
   1413 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   1414 }
   1415 
   1416 /** Prepare test specific data, that will be used as vertex attributes
   1417  *
   1418  *  @param vertex_buffer_infos Vector of vertexBufferInfo instances
   1419  **/
   1420 void GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::prepareVertexBuffersData(
   1421 	std::vector<VertexBufferInfo>& vertex_buffer_infos)
   1422 {
   1423 	/* Constats for offsets and size of buffer */
   1424 	const unsigned int n_total_components = m_n_vertices * m_n_offsets_components;
   1425 
   1426 	/* Limits used to generate offsets */
   1427 	const glw::GLint min_ptgo = m_min_texture_gather_offset;
   1428 	const glw::GLint max_ptgo = m_max_texture_gather_offset;
   1429 
   1430 	/* Storage for offsets */
   1431 	m_offsets_buffer_data.resize(n_total_components);
   1432 
   1433 	/* Set the seed for random number generator */
   1434 	randomSeed(1);
   1435 
   1436 	/* Generate offsets */
   1437 	for (unsigned int i = 0; i < n_total_components; ++i)
   1438 	{
   1439 		m_offsets_buffer_data[i] =
   1440 			static_cast<glw::GLint>(randomFormula(static_cast<glw::GLuint>(max_ptgo - min_ptgo + 1))) + min_ptgo;
   1441 	}
   1442 
   1443 	/* Setup offsets VB info */
   1444 	VertexBufferInfo info;
   1445 
   1446 	info.attribute_name = m_offsets_attribute_name;
   1447 	info.n_components   = m_n_offsets_components;
   1448 	info.type			= GL_INT;
   1449 	info.data			= &m_offsets_buffer_data[0];
   1450 	info.data_size		= (glw::GLuint)(m_offsets_buffer_data.size() * sizeof(glw::GLint));
   1451 
   1452 	/* Add VB info to vector */
   1453 	vertex_buffer_infos.push_back(info);
   1454 }
   1455 
   1456 /** Check if data captured for vertex at index are as expected
   1457  *
   1458  *  @param captured_data Instance of capturedVaryings for vertex at index
   1459  *  @param index         Index of vertex
   1460  *  @param texture_size  Size of texture
   1461  *
   1462  *  @return True  Results match expected values
   1463  *          False Results do not match expected values
   1464  **/
   1465 bool GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::checkResult(const CapturedVaryings& captured_data,
   1466 																	 unsigned int index, unsigned int tex_size)
   1467 {
   1468 	/* Signed int value has to be used with operator % in order to work as expected */
   1469 	const glw::GLint texture_size = (glw::GLint)tex_size;
   1470 
   1471 	/* Get offsets for vertex */
   1472 	glw::GLint x_offset;
   1473 	glw::GLint y_offset;
   1474 
   1475 	getOffsets(x_offset, y_offset, index);
   1476 
   1477 	/* Roll x offsets around left edge when negative */
   1478 	if (0 > x_offset)
   1479 	{
   1480 		x_offset = x_offset % texture_size;
   1481 		x_offset += texture_size;
   1482 	}
   1483 
   1484 	/* Roll y offsets around top edge when negative */
   1485 	if (0 > y_offset)
   1486 	{
   1487 		y_offset = y_offset % texture_size;
   1488 		y_offset += texture_size;
   1489 	}
   1490 
   1491 	/* Storage for expected values of with_offset varyings */
   1492 	glw::GLint expected_values_0[m_n_components_per_varying];
   1493 	glw::GLint expected_values_1[m_n_components_per_varying];
   1494 	glw::GLint expected_values_2[m_n_components_per_varying];
   1495 	glw::GLint expected_values_3[m_n_components_per_varying];
   1496 
   1497 	/* Calculate expected values of with_offset varyings */
   1498 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1499 	{
   1500 		expected_values_0[i] = ((x_offset + captured_data.without_offset_0[i]) % texture_size);
   1501 		expected_values_1[i] = ((y_offset + captured_data.without_offset_1[i]) % texture_size);
   1502 		expected_values_2[i] = ((x_offset + captured_data.without_offset_2[i]) % texture_size);
   1503 		expected_values_3[i] = ((y_offset + captured_data.without_offset_3[i]) % texture_size);
   1504 	}
   1505 
   1506 	/* Verify that expected_values match those in with_offset varyings */
   1507 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1508 	{
   1509 		if ((captured_data.with_offset_0[i] != expected_values_0[i]) ||
   1510 			(captured_data.with_offset_1[i] != expected_values_1[i]) ||
   1511 			(captured_data.with_offset_2[i] != expected_values_2[i]) ||
   1512 			(captured_data.with_offset_3[i] != expected_values_3[i]))
   1513 		{
   1514 			/* Log invalid results */
   1515 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   1516 
   1517 			logCoordinates(index);
   1518 
   1519 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   1520 
   1521 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   1522 							   << tcu::TestLog::EndMessage;
   1523 
   1524 			logVaryings(captured_data);
   1525 
   1526 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   1527 
   1528 			/* Done */
   1529 			return false;
   1530 		}
   1531 	}
   1532 
   1533 	/* Done */
   1534 	return true;
   1535 }
   1536 
   1537 /** Get offsets for vertex at index
   1538  *
   1539  *  @param out_x_offset X offset
   1540  *  @param out_y_offset Y offset
   1541  *  @param index        Index of vertex
   1542  **/
   1543 void GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::getOffsets(glw::GLint& out_x_offset, glw::GLint& out_y_offset,
   1544 																	unsigned int index)
   1545 {
   1546 	out_x_offset = m_offsets_buffer_data[index * m_n_offsets_components + 0];
   1547 	out_y_offset = m_offsets_buffer_data[index * m_n_offsets_components + 1];
   1548 }
   1549 
   1550 /** Constructor
   1551  *
   1552  * @param context       Test context
   1553  * @param name          Test case's name
   1554  * @param description   Test case's description
   1555  **/
   1556 GPUShader5TextureGatherOffsetColor2DArrayCaseTest::GPUShader5TextureGatherOffsetColor2DArrayCaseTest(
   1557 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   1558 	: GPUShader5TextureGatherOffsetColor2DRepeatCaseTest(context, extParams, name, description)
   1559 {
   1560 	/* Nothing to be done here */
   1561 }
   1562 
   1563 /** Get parts of vertex shader
   1564  *
   1565  *  @param out_vertex_shader_parts Vector of vertex shader parts
   1566  **/
   1567 void GPUShader5TextureGatherOffsetColor2DArrayCaseTest::getShaderParts(
   1568 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   1569 {
   1570 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   1571 }
   1572 
   1573 /** Check if texture array is required
   1574  *
   1575  *  @param out_is_texture_array Set to true if texture array is required, false otherwise
   1576  **/
   1577 void GPUShader5TextureGatherOffsetColor2DArrayCaseTest::isTextureArray(bool& out_is_texture_array)
   1578 {
   1579 	out_is_texture_array = true;
   1580 }
   1581 
   1582 /** Constructor
   1583  *
   1584  * @param context       Test context
   1585  * @param name          Test case's name
   1586  * @param description   Test case's description
   1587  **/
   1588 GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest(
   1589 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   1590 	: GPUShader5TextureGatherOffsetColor2DRepeatCaseTest(context, extParams, name, description)
   1591 {
   1592 	/* Nothing to be done here */
   1593 }
   1594 
   1595 /** Get wrap mode for texture
   1596  *
   1597  *  @param out_wrap_mode Wrap mode
   1598  **/
   1599 void GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode)
   1600 {
   1601 	out_wrap_mode = m_glExtTokens.CLAMP_TO_BORDER;
   1602 }
   1603 
   1604 /** Get parts of vertex shader
   1605  *
   1606  *  @param out_vertex_shader_parts Vector of vertex shader parts
   1607  **/
   1608 void GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::getShaderParts(
   1609 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   1610 {
   1611 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   1612 }
   1613 
   1614 /** Check if data captured for vertex at index are as expected
   1615  *
   1616  *  @param captured_data Instance of capturedVaryings for vertex at index
   1617  *  @param index         Index of vertex
   1618  *  @param texture_size  Size of texture
   1619  *
   1620  *  @return True  Results match expected values
   1621  *          False Results do not match expected values
   1622  **/
   1623 bool GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::checkResult(const CapturedVaryings& captured_data,
   1624 																			unsigned int			index,
   1625 																			unsigned int			texture_size)
   1626 {
   1627 	/* Get offsets for vertex */
   1628 	glw::GLint x_offset;
   1629 	glw::GLint y_offset;
   1630 
   1631 	getOffsets(x_offset, y_offset, index);
   1632 
   1633 	/* Storage for expected values of with_offset varyings */
   1634 	glw::GLint expected_values_0[m_n_components_per_varying];
   1635 	glw::GLint expected_values_1[m_n_components_per_varying];
   1636 	glw::GLint expected_values_2[m_n_components_per_varying];
   1637 	glw::GLint expected_values_3[m_n_components_per_varying];
   1638 
   1639 	/* Storage for with_offset values */
   1640 	glw::GLint with_offset_0[m_n_components_per_varying];
   1641 	glw::GLint with_offset_1[m_n_components_per_varying];
   1642 	glw::GLint with_offset_2[m_n_components_per_varying];
   1643 	glw::GLint with_offset_3[m_n_components_per_varying];
   1644 
   1645 	/* Index of first not clamped texel in without_offset set*/
   1646 	int not_clamped_texel_index = -1;
   1647 
   1648 	/* X and Y offsets of texels in 2x2 set */
   1649 	static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 };
   1650 	static const glw::GLint gather_offsets_y[] = { 1, 1, 0, 0 };
   1651 
   1652 	/* Find first not clamped texel in without_offset set */
   1653 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1654 	{
   1655 		if ((0 <= captured_data.without_offset_0[i]) && (0 <= captured_data.without_offset_1[i]))
   1656 		{
   1657 			not_clamped_texel_index = i;
   1658 			break;
   1659 		}
   1660 	}
   1661 
   1662 	if (-1 == not_clamped_texel_index)
   1663 	{
   1664 		/* Log problem with sampler */
   1665 		m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", "");
   1666 
   1667 		logCoordinates(index);
   1668 
   1669 		m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   1670 
   1671 		m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   1672 						   << tcu::TestLog::EndMessage;
   1673 
   1674 		logVaryings(captured_data);
   1675 
   1676 		m_testCtx.getLog() << tcu::TestLog::EndSection;
   1677 
   1678 		TCU_FAIL("Unexpected sampling results");
   1679 	}
   1680 
   1681 	/* Fraction part of position for lower left texel without_offset set */
   1682 	const glw::GLint fract_position_x =
   1683 		captured_data.without_offset_0[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index];
   1684 	const glw::GLint fract_position_y =
   1685 		captured_data.without_offset_1[not_clamped_texel_index] - gather_offsets_y[not_clamped_texel_index];
   1686 
   1687 	/* Absolute position of lower left corner in without_offset set */
   1688 	const glw::GLint absolute_position_x = fract_position_x + captured_data.without_offset_2[0] * (int)texture_size;
   1689 	const glw::GLint absolute_position_y = fract_position_y + captured_data.without_offset_3[0] * (int)texture_size;
   1690 
   1691 	/* Calculate absolute position for all texels in without_offset set */
   1692 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1693 	{
   1694 		expected_values_0[i] = absolute_position_x + gather_offsets_x[i];
   1695 		expected_values_1[i] = absolute_position_y + gather_offsets_y[i];
   1696 		expected_values_2[i] = absolute_position_x + gather_offsets_x[i];
   1697 		expected_values_3[i] = absolute_position_y + gather_offsets_y[i];
   1698 	}
   1699 
   1700 	/* Modify "border color" to -1 in with_offset set */
   1701 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1702 	{
   1703 		with_offset_0[i] = 0 <= captured_data.with_offset_0[i] ? captured_data.with_offset_0[i] : -1;
   1704 		with_offset_1[i] = 0 <= captured_data.with_offset_1[i] ? captured_data.with_offset_1[i] : -1;
   1705 		with_offset_2[i] = 0 <= captured_data.with_offset_2[i] ? captured_data.with_offset_2[i] : -1;
   1706 		with_offset_3[i] = 0 <= captured_data.with_offset_3[i] ? captured_data.with_offset_3[i] : -1;
   1707 	}
   1708 
   1709 	/* Apply offsets to absolute positions of without_offset */
   1710 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1711 	{
   1712 		expected_values_0[i] += x_offset;
   1713 		expected_values_1[i] += y_offset;
   1714 		expected_values_2[i] += x_offset;
   1715 		expected_values_3[i] += y_offset;
   1716 
   1717 		/* Set to -1, when point defined by expected_values_01 is outside of texture */
   1718 		if ((0 > expected_values_0[i]) || (((glw::GLint)texture_size) <= expected_values_0[i]) ||
   1719 			(0 > expected_values_1[i]) || (((glw::GLint)texture_size) <= expected_values_1[i]))
   1720 		{
   1721 			expected_values_0[i] = -1;
   1722 			expected_values_1[i] = -1;
   1723 		}
   1724 
   1725 		/* Set to -1, when point defined by expected_values_23 is outside of texture */
   1726 		if ((0 > expected_values_2[i]) || (((glw::GLint)texture_size) <= expected_values_2[i]) ||
   1727 			(0 > expected_values_3[i]) || (((glw::GLint)texture_size) <= expected_values_3[i]))
   1728 		{
   1729 			expected_values_2[i] = -1;
   1730 			expected_values_3[i] = -1;
   1731 		}
   1732 	}
   1733 
   1734 	/* Verify that expected_values match those in with_offset varyings */
   1735 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1736 	{
   1737 		if ((with_offset_0[i] != expected_values_0[i]) || (with_offset_1[i] != expected_values_1[i]) ||
   1738 			(with_offset_2[i] != expected_values_2[i]) || (with_offset_3[i] != expected_values_3[i]))
   1739 		{
   1740 			/* Log invalid results */
   1741 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   1742 
   1743 			logCoordinates(index);
   1744 
   1745 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   1746 
   1747 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   1748 							   << tcu::TestLog::EndMessage;
   1749 
   1750 			logVaryings(captured_data);
   1751 
   1752 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   1753 
   1754 			/* Done */
   1755 			return false;
   1756 		}
   1757 	}
   1758 
   1759 	/* Done */
   1760 	return true;
   1761 }
   1762 
   1763 /** Initializes GLES objects used during the test.
   1764  *
   1765  */
   1766 void GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::initTest(void)
   1767 {
   1768 	/* Check if texture_border_clamp extension is supported */
   1769 	if (!m_is_texture_border_clamp_supported)
   1770 	{
   1771 		throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__);
   1772 	}
   1773 
   1774 	GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::initTest();
   1775 }
   1776 
   1777 /** Constructor
   1778  *
   1779  * @param context       Test context
   1780  * @param name          Test case's name
   1781  * @param description   Test case's description
   1782  **/
   1783 GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest(
   1784 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   1785 	: GPUShader5TextureGatherOffsetColor2DRepeatCaseTest(context, extParams, name, description)
   1786 {
   1787 	/* Nothing to be done here */
   1788 }
   1789 
   1790 /** Get wrap mode for texture
   1791  *
   1792  *  @param out_wrap_mode Wrap mode
   1793  **/
   1794 void GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode)
   1795 {
   1796 	out_wrap_mode = GL_CLAMP_TO_EDGE;
   1797 }
   1798 
   1799 /** Get parts of vertex shader
   1800  *
   1801  *  @param out_vertex_shader_parts Vector of vertex shader parts
   1802  **/
   1803 void GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::getShaderParts(
   1804 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   1805 {
   1806 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   1807 }
   1808 
   1809 /** Clamps value to specified range
   1810  *
   1811  * @param value Value to be clamped
   1812  * @param min   Minimum of range
   1813  * @param max   Maximum of range
   1814  **/
   1815 template <typename T>
   1816 void clamp(T& value, const T min, const T max)
   1817 {
   1818 	if (min > value)
   1819 	{
   1820 		value = min;
   1821 	}
   1822 	else if (max < value)
   1823 	{
   1824 		value = max;
   1825 	}
   1826 }
   1827 
   1828 /** Check if data captured for vertex at index are as expected
   1829  *
   1830  *  @param captured_data Instance of capturedVaryings for vertex at index
   1831  *  @param index         Index of vertex
   1832  *  @param texture_size Size of texture
   1833  *
   1834  *  @return True  Results match expected values
   1835  *          False Results do not match expected values
   1836  **/
   1837 bool GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::checkResult(const CapturedVaryings& captured_data,
   1838 																		  unsigned int index, unsigned int texture_size)
   1839 {
   1840 	/* Get offsets for vertex */
   1841 	glw::GLint x_offset;
   1842 	glw::GLint y_offset;
   1843 
   1844 	getOffsets(x_offset, y_offset, index);
   1845 
   1846 	/* Storage for expected values of with_offset varyings */
   1847 	glw::GLint expected_values_0[m_n_components_per_varying];
   1848 	glw::GLint expected_values_1[m_n_components_per_varying];
   1849 	glw::GLint expected_values_2[m_n_components_per_varying];
   1850 	glw::GLint expected_values_3[m_n_components_per_varying];
   1851 
   1852 	/* Index of first not clamped texel in without_offset set*/
   1853 	int not_clamped_texel_index = -1;
   1854 
   1855 	/* X and Y offsets of texels in 2x2 set */
   1856 	static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 };
   1857 	static const glw::GLint gather_offsets_y[] = { 1, 1, 0, 0 };
   1858 
   1859 	/* Find first not clamped texel in without_offset set */
   1860 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1861 	{
   1862 		if ((0 <= captured_data.without_offset_0[i]) && (0 <= captured_data.without_offset_1[i]))
   1863 		{
   1864 			not_clamped_texel_index = i;
   1865 			break;
   1866 		}
   1867 	}
   1868 
   1869 	if (-1 == not_clamped_texel_index)
   1870 	{
   1871 		/* Log problem with sampler */
   1872 		m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", "");
   1873 
   1874 		logCoordinates(index);
   1875 
   1876 		m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   1877 
   1878 		m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   1879 						   << tcu::TestLog::EndMessage;
   1880 
   1881 		logVaryings(captured_data);
   1882 
   1883 		m_testCtx.getLog() << tcu::TestLog::EndSection;
   1884 
   1885 		TCU_FAIL("Unexpected sampling results");
   1886 	}
   1887 
   1888 	/* Fraction part of position for lower left texel without_offset set */
   1889 	const glw::GLint fract_position_x =
   1890 		captured_data.without_offset_0[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index];
   1891 	const glw::GLint fract_position_y =
   1892 		captured_data.without_offset_1[not_clamped_texel_index] - gather_offsets_y[not_clamped_texel_index];
   1893 
   1894 	/* Absolute position of lower left corner in without_offset set */
   1895 	const glw::GLint absolute_position_x = fract_position_x + captured_data.without_offset_2[0] * (int)texture_size;
   1896 	const glw::GLint absolute_position_y = fract_position_y + captured_data.without_offset_3[0] * (int)texture_size;
   1897 
   1898 	/* Calculate absolute position for all texels in without_offset set */
   1899 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1900 	{
   1901 		expected_values_0[i] = absolute_position_x + gather_offsets_x[i];
   1902 		expected_values_1[i] = absolute_position_y + gather_offsets_y[i];
   1903 		expected_values_2[i] = absolute_position_x + gather_offsets_x[i];
   1904 		expected_values_3[i] = absolute_position_y + gather_offsets_y[i];
   1905 	}
   1906 
   1907 	/* Apply offsets to absolute positions of without_offset */
   1908 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1909 	{
   1910 		expected_values_0[i] += x_offset;
   1911 		expected_values_1[i] += y_offset;
   1912 		expected_values_2[i] += x_offset;
   1913 		expected_values_3[i] += y_offset;
   1914 
   1915 		/* Clamp value when point is outside of texture */
   1916 		clamp(expected_values_0[i], 0, ((glw::GLint)texture_size) - 1);
   1917 		clamp(expected_values_1[i], 0, ((glw::GLint)texture_size) - 1);
   1918 		clamp(expected_values_2[i], 0, ((glw::GLint)texture_size) - 1);
   1919 		clamp(expected_values_3[i], 0, ((glw::GLint)texture_size) - 1);
   1920 	}
   1921 
   1922 	/* Verify that expected_values match those in with_offset varyings */
   1923 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   1924 	{
   1925 		if ((captured_data.with_offset_0[i] != expected_values_0[i]) ||
   1926 			(captured_data.with_offset_1[i] != expected_values_1[i]) ||
   1927 			(captured_data.with_offset_2[i] != expected_values_2[i]) ||
   1928 			(captured_data.with_offset_3[i] != expected_values_3[i]))
   1929 		{
   1930 			/* Log invalid results */
   1931 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   1932 
   1933 			logCoordinates(index);
   1934 
   1935 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   1936 
   1937 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   1938 							   << tcu::TestLog::EndMessage;
   1939 
   1940 			logVaryings(captured_data);
   1941 
   1942 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   1943 
   1944 			/* Done */
   1945 			return false;
   1946 		}
   1947 	}
   1948 
   1949 	/* Done */
   1950 	return true;
   1951 }
   1952 
   1953 /** Constructor
   1954  *
   1955  * @param context       Test context
   1956  * @param name          Test case's name
   1957  * @param description   Test case's description
   1958  **/
   1959 GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest(
   1960 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   1961 	: GPUShader5TextureGatherOffsetColorTestBase(context, extParams, name, description)
   1962 {
   1963 	/* Nothing to be done here */
   1964 }
   1965 
   1966 /** Get parts of vertex shader
   1967  *
   1968  *  @param out_vertex_shader_parts Vector of vertex shader parts
   1969  **/
   1970 void GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::getShaderParts(
   1971 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   1972 {
   1973 	std::stringstream stream;
   1974 
   1975 	stream << "           ivec2[4]( ivec2( " << m_min_texture_gather_offset << ", " << m_min_texture_gather_offset
   1976 		   << "),\n";
   1977 	stream << "                     ivec2( " << m_min_texture_gather_offset << ", " << m_max_texture_gather_offset
   1978 		   << "),\n";
   1979 	stream << "                     ivec2( " << m_max_texture_gather_offset << ", " << m_min_texture_gather_offset
   1980 		   << "),\n";
   1981 	stream << "                     ivec2( " << m_max_texture_gather_offset << ", " << m_max_texture_gather_offset
   1982 		   << "));\n";
   1983 
   1984 	m_vertex_shader_code_offsets = stream.str();
   1985 
   1986 	out_vertex_shader_parts.push_back(m_vertex_shader_code_preamble);
   1987 	out_vertex_shader_parts.push_back(m_vertex_shader_code_offsets.c_str());
   1988 	out_vertex_shader_parts.push_back(m_vertex_shader_code_body);
   1989 }
   1990 
   1991 /** Prepare test specific data, that will be used as vertex attributes
   1992  *
   1993  *  @param vertex_buffer_infos Vector of vertexBufferInfo instances
   1994  **/
   1995 void GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::prepareVertexBuffersData(
   1996 	std::vector<VertexBufferInfo>& vertex_buffer_infos)
   1997 {
   1998 	DE_UNREF(vertex_buffer_infos);
   1999 
   2000 	/* Nothing to be done here */
   2001 }
   2002 
   2003 /** Check if data captured for vertex at index are as expected
   2004  *
   2005  *  @param captured_data Instance of capturedVaryings for vertex at index
   2006  *  @param index         Index of vertex
   2007  *  @param texture_size  Size of texture
   2008  *
   2009  *  @return True  Results match expected values
   2010  *          False Results do not match expected values
   2011  **/
   2012 bool GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::checkResult(const CapturedVaryings& captured_data,
   2013 																	  unsigned int index, unsigned int tex_size)
   2014 {
   2015 	/* Signed int value has to be used with operator % in order to work as expected */
   2016 	const glw::GLint texture_size = (glw::GLint)tex_size;
   2017 
   2018 	/* X and Y offsets */
   2019 	glw::GLint x_offsets[m_n_components_per_varying] = {
   2020 		m_min_texture_gather_offset, m_min_texture_gather_offset, m_max_texture_gather_offset,
   2021 		m_max_texture_gather_offset,
   2022 	};
   2023 
   2024 	glw::GLint y_offsets[m_n_components_per_varying] = {
   2025 		m_min_texture_gather_offset, m_max_texture_gather_offset, m_min_texture_gather_offset,
   2026 		m_max_texture_gather_offset,
   2027 	};
   2028 
   2029 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2030 	{
   2031 		/* Roll x offsets around left edge when negative */
   2032 		if (0 > x_offsets[i])
   2033 		{
   2034 			x_offsets[i] = x_offsets[i] % texture_size;
   2035 			x_offsets[i] += texture_size;
   2036 		}
   2037 
   2038 		/* Roll y offsets around top edge when negative */
   2039 		if (0 > y_offsets[i])
   2040 		{
   2041 			y_offsets[i] = y_offsets[i] % texture_size;
   2042 			y_offsets[i] += texture_size;
   2043 		}
   2044 	}
   2045 
   2046 	/* Storage for expected values of with_offset varyings */
   2047 	glw::GLint expected_values_0[m_n_components_per_varying];
   2048 	glw::GLint expected_values_1[m_n_components_per_varying];
   2049 	glw::GLint expected_values_2[m_n_components_per_varying];
   2050 	glw::GLint expected_values_3[m_n_components_per_varying];
   2051 
   2052 	/* Calculate expected values of with_offset varyings */
   2053 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2054 	{
   2055 		expected_values_0[i] = ((x_offsets[i] + captured_data.without_offset_0[3]) % texture_size);
   2056 		expected_values_1[i] = ((y_offsets[i] + captured_data.without_offset_1[3]) % texture_size);
   2057 		expected_values_2[i] = ((x_offsets[i] + captured_data.without_offset_2[3]) % texture_size);
   2058 		expected_values_3[i] = ((y_offsets[i] + captured_data.without_offset_3[3]) % texture_size);
   2059 	}
   2060 
   2061 	/* Verify that expected_values match those in with_offset varyings */
   2062 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2063 	{
   2064 		if ((captured_data.with_offset_0[i] != expected_values_0[i]) ||
   2065 			(captured_data.with_offset_1[i] != expected_values_1[i]) ||
   2066 			(captured_data.with_offset_2[i] != expected_values_2[i]) ||
   2067 			(captured_data.with_offset_3[i] != expected_values_3[i]))
   2068 		{
   2069 			/* Log invalid results */
   2070 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   2071 
   2072 			logCoordinates(index);
   2073 
   2074 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   2075 
   2076 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: "
   2077 							   << "(" << x_offsets[0] << ", " << y_offsets[0] << ") "
   2078 							   << "(" << x_offsets[1] << ", " << y_offsets[1] << ") "
   2079 							   << "(" << x_offsets[2] << ", " << y_offsets[2] << ") "
   2080 							   << "(" << x_offsets[3] << ", " << y_offsets[3] << ") " << tcu::TestLog::EndMessage;
   2081 
   2082 			logVaryings(captured_data);
   2083 
   2084 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   2085 
   2086 			/* Done */
   2087 			return false;
   2088 		}
   2089 	}
   2090 
   2091 	/* Done */
   2092 	return true;
   2093 }
   2094 
   2095 /** Initializes GLES objects used during the test.
   2096  *
   2097  */
   2098 void GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::initTest(void)
   2099 {
   2100 	/* Check if texture_border_clamp extension is supported */
   2101 	if (!m_is_texture_border_clamp_supported)
   2102 	{
   2103 		throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__);
   2104 	}
   2105 
   2106 	GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::initTest();
   2107 }
   2108 
   2109 /** Constructor
   2110  *
   2111  * @param context       Test context
   2112  * @param name          Test case's name
   2113  * @param description   Test case's description
   2114  **/
   2115 GPUShader5TextureGatherOffsetDepthTestBase::GPUShader5TextureGatherOffsetDepthTestBase(Context&				context,
   2116 																					   const ExtParameters& extParams,
   2117 																					   const char*			name,
   2118 																					   const char*			description)
   2119 	: GPUShader5TextureGatherOffsetTestBase(context, extParams, name, description), m_n_varyings_per_vertex(0)
   2120 {
   2121 	/* Nothing to be done here */
   2122 }
   2123 
   2124 /** Provides color that will be used as border color for "clamp to border" mode
   2125  *
   2126  * @param out_color Color
   2127  **/
   2128 void GPUShader5TextureGatherOffsetDepthTestBase::getBorderColor(glw::GLfloat out_color[4])
   2129 {
   2130 	out_color[0] = 1.0f;
   2131 	out_color[1] = 1.0f;
   2132 	out_color[2] = 1.0f;
   2133 	out_color[3] = 1.0f;
   2134 }
   2135 
   2136 /** Provides informations required to create texture
   2137  *
   2138  *  @param out_width                   Size of texture
   2139  *  @param out_texture_internal_format Internal format of texture
   2140  *  @param out_texture_format          Format of texture
   2141  *  @param out_texture_type            Type of texture
   2142  *  @param out_bytes_per_pixel         Bytes per pixel
   2143  **/
   2144 void GPUShader5TextureGatherOffsetDepthTestBase::getTextureInfo(glw::GLuint& out_width,
   2145 																glw::GLenum& out_texture_internal_format,
   2146 																glw::GLenum& out_texture_format,
   2147 																glw::GLenum& out_texture_type,
   2148 																glw::GLuint& out_bytes_per_pixel)
   2149 {
   2150 	out_width					= m_texture_size;
   2151 	out_texture_internal_format = GL_DEPTH_COMPONENT32F;
   2152 	out_texture_format			= GL_DEPTH_COMPONENT;
   2153 	out_texture_type			= GL_FLOAT;
   2154 	out_bytes_per_pixel			= 1 * sizeof(glw::GLfloat); /* Depth * float */
   2155 }
   2156 
   2157 /** Get wrap mode for texture
   2158  *
   2159  *  @param out_wrap_mode Wrap mode
   2160  **/
   2161 void GPUShader5TextureGatherOffsetDepthTestBase::getTextureWrapMode(glw::GLenum& out_wrap_mode)
   2162 {
   2163 	out_wrap_mode = GL_REPEAT;
   2164 }
   2165 
   2166 /** Get size of buffer used as output from transform feedback and names of varyings
   2167  *
   2168  *  @param out_buffer_size       Size of buffer
   2169  *  @param out_captured_varyings Names of varyings
   2170  **/
   2171 void GPUShader5TextureGatherOffsetDepthTestBase::getTransformFeedBackDetails(
   2172 	glw::GLuint& out_buffer_size, std::vector<const glw::GLchar*>& out_captured_varyings)
   2173 {
   2174 	getVaryings(out_captured_varyings);
   2175 
   2176 	m_n_varyings_per_vertex = (unsigned int)out_captured_varyings.size();
   2177 
   2178 	out_buffer_size = static_cast<glw::GLuint>(m_n_vertices * m_n_varyings_per_vertex * m_n_components_per_varying *
   2179 											   sizeof(glw::GLint));
   2180 }
   2181 
   2182 /** Check if texture array is required
   2183  *
   2184  *  @param out_is_texture_array Set to true if texture array is required, false otherwise
   2185  **/
   2186 void GPUShader5TextureGatherOffsetDepthTestBase::isTextureArray(bool& out_is_texture_array)
   2187 {
   2188 	out_is_texture_array = false;
   2189 }
   2190 
   2191 /** Prepare texture data as expected by all cases in test 10.
   2192  *  Each texel is assigned value of { x / texture_size }
   2193  *
   2194  *  @param data Storage space for texture data
   2195  **/
   2196 void GPUShader5TextureGatherOffsetDepthTestBase::prepareTextureData(glw::GLubyte* data)
   2197 {
   2198 	/* Data pointer */
   2199 	glw::GLfloat* texture_data = (glw::GLfloat*)data;
   2200 
   2201 	/* Constants */
   2202 	const unsigned int n_components_per_pixel = 1;
   2203 	const unsigned int line_size			  = n_components_per_pixel * m_texture_size;
   2204 	const glw::GLfloat step					  = 1.0f / ((float)m_texture_size);
   2205 
   2206 	/* Prepare texture's data */
   2207 	for (unsigned int y = 0; y < m_texture_size; ++y)
   2208 	{
   2209 		for (unsigned int x = 0; x < m_texture_size; ++x)
   2210 		{
   2211 			const glw::GLfloat depth		= ((float)x) * step;
   2212 			const unsigned int pixel_offset = y * line_size + x * n_components_per_pixel;
   2213 
   2214 			/* texel.depth = depth */
   2215 			texture_data[pixel_offset] = depth;
   2216 		}
   2217 	}
   2218 }
   2219 
   2220 /** Verification of results
   2221  *
   2222  *  @param result Pointer to data mapped from transform feedback buffer.
   2223  *                Size of data is equal to buffer_size set by getTransformFeedbackBufferSize
   2224  *
   2225  *  @return true  Result match expected value
   2226  *          false Result has wrong value
   2227  **/
   2228 bool GPUShader5TextureGatherOffsetDepthTestBase::verifyResult(const void* result_data)
   2229 {
   2230 	/* All data stored in data are ints */
   2231 	glw::GLint* results = (glw::GLint*)result_data;
   2232 
   2233 	/* Verification result */
   2234 	bool result = true;
   2235 
   2236 	/* Constants for data offsets calculation */
   2237 	const unsigned int bytes_per_varying			 = m_n_components_per_varying * sizeof(glw::GLfloat);
   2238 	const unsigned int vertex_size_in_results_buffer = m_n_varyings_per_vertex * m_n_components_per_varying;
   2239 	const unsigned int with_offset_offset			 = m_n_components_per_varying;
   2240 	const unsigned int without_offset_offset		 = 0;
   2241 	const unsigned int floor_tex_coord_offset		 = with_offset_offset + m_n_components_per_varying;
   2242 
   2243 	/* For each vertex */
   2244 	for (unsigned int vertex = 0; vertex < m_n_vertices; ++vertex)
   2245 	{
   2246 		CapturedVaryings captured_data;
   2247 
   2248 		/* Pointers to all varyings for given vertex */
   2249 		const glw::GLint* without_offset  = results + (vertex * vertex_size_in_results_buffer) + without_offset_offset;
   2250 		const glw::GLint* with_offset	 = results + (vertex * vertex_size_in_results_buffer) + with_offset_offset;
   2251 		const glw::GLint* floor_tex_coord = results + (vertex * vertex_size_in_results_buffer) + floor_tex_coord_offset;
   2252 
   2253 		/* Copy captured varyings to captured_data instance */
   2254 		memcpy(captured_data.without_offset, without_offset, bytes_per_varying);
   2255 		memcpy(captured_data.with_offset, with_offset, bytes_per_varying);
   2256 		if (3 <= m_n_varyings_per_vertex)
   2257 		{
   2258 			memcpy(captured_data.floor_tex_coord, floor_tex_coord, bytes_per_varying);
   2259 		}
   2260 
   2261 		/* Let child class check if result is ok */
   2262 		const bool is_result_ok = checkResult(captured_data, vertex, m_texture_size);
   2263 
   2264 		/* Do not break on first error */
   2265 		if (false == is_result_ok)
   2266 		{
   2267 			result = false;
   2268 		}
   2269 	}
   2270 
   2271 	/* Done */
   2272 	return result;
   2273 }
   2274 
   2275 /** Provides names of varyings to be captured by test
   2276  *
   2277  * @param out_captured_varyings Vector of varyings' names
   2278  **/
   2279 void GPUShader5TextureGatherOffsetDepthTestBase::getVaryings(std::vector<const glw::GLchar*>& out_captured_varyings)
   2280 {
   2281 	out_captured_varyings.push_back("without_offset");
   2282 	out_captured_varyings.push_back("with_offset");
   2283 }
   2284 
   2285 /** Logs data captured varyings
   2286  *
   2287  *  @param varyings Instance of capturedVaryings to be logged
   2288  **/
   2289 void GPUShader5TextureGatherOffsetDepthTestBase::logVaryings(const CapturedVaryings& varyings)
   2290 {
   2291 	logArray(varyings.without_offset, m_n_components_per_varying, "Without offset: ");
   2292 
   2293 	logArray(varyings.with_offset, m_n_components_per_varying, "With offset: ");
   2294 }
   2295 
   2296 /** Constructor
   2297  *
   2298  * @param context       Test context
   2299  * @param name          Test case's name
   2300  * @param description   Test case's description
   2301  **/
   2302 GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(
   2303 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   2304 	: GPUShader5TextureGatherOffsetDepthTestBase(context, extParams, name, description)
   2305 {
   2306 	/* Nothing to be done here */
   2307 }
   2308 
   2309 /** Get parts of vertex shader
   2310  *
   2311  *  @param out_vertex_shader_parts Vector of vertex shader parts
   2312  **/
   2313 void GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::getShaderParts(
   2314 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   2315 {
   2316 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   2317 }
   2318 
   2319 /** Prepare test specific data, that will be used as vertex attributes
   2320  *
   2321  *  @param vertex_buffer_infos Vector of vertexBufferInfo instances
   2322  **/
   2323 void GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::prepareVertexBuffersData(
   2324 	std::vector<VertexBufferInfo>& vertex_buffer_infos)
   2325 {
   2326 	/* Constants for offsets and size of buffer */
   2327 	const unsigned int n_total_components = m_n_vertices * m_n_offsets_components;
   2328 
   2329 	/* Limits used to generate offsets */
   2330 	const glw::GLint min_ptgo = m_min_texture_gather_offset;
   2331 	const glw::GLint max_ptgo = m_max_texture_gather_offset;
   2332 
   2333 	/* Storage for offsets */
   2334 	m_offsets_buffer_data.resize(n_total_components);
   2335 
   2336 	/* Generate offsets */
   2337 	for (unsigned int i = 0; i < n_total_components; ++i)
   2338 	{
   2339 		m_offsets_buffer_data[i] = (rand() % (max_ptgo - min_ptgo + 1)) + min_ptgo;
   2340 	}
   2341 
   2342 	/* Setup offsets VB info */
   2343 	VertexBufferInfo info;
   2344 
   2345 	info.attribute_name = m_offsets_attribute_name;
   2346 	info.n_components   = m_n_offsets_components;
   2347 	info.type			= GL_INT;
   2348 	info.data			= &m_offsets_buffer_data[0];
   2349 	info.data_size		= (glw::GLuint)(m_offsets_buffer_data.size() * sizeof(glw::GLint));
   2350 
   2351 	/* Add VB info to vector */
   2352 	vertex_buffer_infos.push_back(info);
   2353 }
   2354 
   2355 /** Check if data captured for vertex at index are as expected
   2356  *
   2357  *  @param captured_data Instance of capturedVaryings for vertex at index
   2358  *  @param index         Index of vertex
   2359  *  @param texture_size  Size of texture
   2360  *
   2361  *  @return True  Results match expected values
   2362  *          False Results do not match expected values
   2363  **/
   2364 bool GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::checkResult(const CapturedVaryings& captured_data,
   2365 																	 unsigned int index, unsigned int tex_size)
   2366 {
   2367 	/* Signed int value has to be used with operator % in order to work as expected */
   2368 	const glw::GLint texture_size = (glw::GLint)tex_size;
   2369 
   2370 	/* Get offsets for vertex */
   2371 	glw::GLint x_offset;
   2372 	glw::GLint y_offset;
   2373 
   2374 	getOffsets(x_offset, y_offset, index);
   2375 
   2376 	/* Roll x offsets around left edge when negative */
   2377 	if (0 > x_offset)
   2378 	{
   2379 		x_offset = x_offset % texture_size;
   2380 		x_offset += texture_size;
   2381 	}
   2382 
   2383 	/* Storage for expected values of with_offset varyings */
   2384 	glw::GLint expected_values[m_n_components_per_varying];
   2385 
   2386 	/* Calculate expected values of with_offset varyings */
   2387 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2388 	{
   2389 		expected_values[i] = ((x_offset + captured_data.without_offset[i]) % texture_size);
   2390 	}
   2391 
   2392 	/* Verify that expected_values match those in with_offset varyings */
   2393 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2394 	{
   2395 		if (captured_data.with_offset[i] != expected_values[i])
   2396 		{
   2397 			/* Log invalid results */
   2398 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   2399 
   2400 			logCoordinates(index);
   2401 
   2402 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   2403 
   2404 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   2405 							   << tcu::TestLog::EndMessage;
   2406 
   2407 			logVaryings(captured_data);
   2408 
   2409 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   2410 
   2411 			/* Done */
   2412 			return false;
   2413 		}
   2414 	}
   2415 
   2416 	/* Done */
   2417 	return true;
   2418 }
   2419 
   2420 /** Get offsets for vertex at index
   2421  *
   2422  *  @param out_x_offset X offset
   2423  *  @param out_y_offset Y offset
   2424  *  @param index        Index of vertex
   2425  **/
   2426 void GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::getOffsets(glw::GLint& out_x_offset, glw::GLint& out_y_offset,
   2427 																	unsigned int index)
   2428 {
   2429 	out_x_offset = m_offsets_buffer_data[index * m_n_offsets_components + 0];
   2430 	out_y_offset = m_offsets_buffer_data[index * m_n_offsets_components + 1];
   2431 }
   2432 
   2433 /** Constructor
   2434  *
   2435  * @param context       Test context
   2436  * @param name          Test case's name
   2437  * @param description   Test case's description
   2438  **/
   2439 GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest(
   2440 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   2441 	: GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description)
   2442 {
   2443 	/* Nothing to be done here */
   2444 }
   2445 
   2446 /** Get parts of vertex shader
   2447  *
   2448  *  @param out_vertex_shader_parts Vector of vertex shader parts
   2449  **/
   2450 void GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::getShaderParts(
   2451 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   2452 {
   2453 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   2454 }
   2455 
   2456 /** Prepare texture data as expected by case "Repeat the same test for Y axis." of test 10.
   2457  *  Each texel is assigned value of { y / texture_size }
   2458  *
   2459  *  @param data Storage space for texture data
   2460  **/
   2461 void GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::prepareTextureData(glw::GLubyte* data)
   2462 {
   2463 	/* Data pointer */
   2464 	glw::GLfloat* texture_data = (glw::GLfloat*)data;
   2465 
   2466 	/* Get texture info from GPUShader5TextureGatherOffsetDepthTestBase */
   2467 	glw::GLuint texture_size;
   2468 	glw::GLenum ignored_texture_internal_format;
   2469 	glw::GLenum ignored_texture_format;
   2470 	glw::GLenum ignored_texture_type;
   2471 	glw::GLuint ignored_bytes_per_pixel;
   2472 
   2473 	getTextureInfo(texture_size, ignored_texture_internal_format, ignored_texture_format, ignored_texture_type,
   2474 				   ignored_bytes_per_pixel);
   2475 
   2476 	/* Constants */
   2477 	const unsigned int n_components_per_pixel = 1;
   2478 	const unsigned int line_size			  = n_components_per_pixel * texture_size;
   2479 	const glw::GLfloat step					  = 1.0f / ((float)texture_size);
   2480 
   2481 	/* Prepare texture's data */
   2482 	for (unsigned int y = 0; y < texture_size; ++y)
   2483 	{
   2484 		const glw::GLfloat depth = ((float)y) * step;
   2485 
   2486 		for (unsigned int x = 0; x < texture_size; ++x)
   2487 		{
   2488 			const unsigned int pixel_offset = y * line_size + x * n_components_per_pixel;
   2489 
   2490 			/* texel.depth = depth */
   2491 			texture_data[pixel_offset] = depth;
   2492 		}
   2493 	}
   2494 }
   2495 
   2496 /** Check if data captured for vertex at index are as expected
   2497  *
   2498  *  @param captured_data Instance of capturedVaryings for vertex at index
   2499  *  @param index         Index of vertex
   2500  *  @param texture_size  Size of texture
   2501  *
   2502  *  @return True  Results match expected values
   2503  *          False Results do not match expected values
   2504  **/
   2505 bool GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::checkResult(const CapturedVaryings& captured_data,
   2506 																	  unsigned int index, unsigned int tex_size)
   2507 {
   2508 	/* Signed int value has to be used with operator % in order to work as expected */
   2509 	const glw::GLint texture_size = (glw::GLint)tex_size;
   2510 
   2511 	/* Get offsets for vertex */
   2512 	glw::GLint x_offset;
   2513 	glw::GLint y_offset;
   2514 
   2515 	getOffsets(x_offset, y_offset, index);
   2516 
   2517 	/* Roll y offsets around left edge when negative */
   2518 	if (0 > y_offset)
   2519 	{
   2520 		y_offset = y_offset % texture_size;
   2521 		y_offset += texture_size;
   2522 	}
   2523 
   2524 	/* Storage for expected values of with_offset varyings */
   2525 	glw::GLint expected_values[m_n_components_per_varying];
   2526 
   2527 	/* Calculate expected values of with_offset varyings */
   2528 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2529 	{
   2530 		expected_values[i] = ((y_offset + captured_data.without_offset[i]) % texture_size);
   2531 	}
   2532 
   2533 	/* Verify that expected_values match those in with_offset varyings */
   2534 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2535 	{
   2536 		if (captured_data.with_offset[i] != expected_values[i])
   2537 		{
   2538 			/* Log invalid results */
   2539 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   2540 
   2541 			logCoordinates(index);
   2542 
   2543 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   2544 
   2545 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   2546 							   << tcu::TestLog::EndMessage;
   2547 
   2548 			logVaryings(captured_data);
   2549 
   2550 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   2551 
   2552 			/* Done */
   2553 			return false;
   2554 		}
   2555 	}
   2556 
   2557 	/* Done */
   2558 	return true;
   2559 }
   2560 
   2561 /** Constructor
   2562  *
   2563  * @param context       Test context
   2564  * @param name          Test case's name
   2565  * @param description   Test case's description
   2566  **/
   2567 GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::GPUShader5TextureGatherOffsetDepth2DArrayCaseTest(
   2568 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   2569 	: GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description)
   2570 {
   2571 	/* Nothing to be done here */
   2572 }
   2573 
   2574 /** Get parts of vertex shader
   2575  *
   2576  *  @param out_vertex_shader_parts Vector of vertex shader parts
   2577  **/
   2578 void GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::getShaderParts(
   2579 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   2580 {
   2581 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   2582 }
   2583 
   2584 /** Check if texture array is required
   2585  *
   2586  *  @param out_is_texture_array Set to true if texture array is required, false otherwise
   2587  **/
   2588 void GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::isTextureArray(bool& out_is_texture_array)
   2589 {
   2590 	out_is_texture_array = true;
   2591 }
   2592 
   2593 /** Constructor
   2594  *
   2595  * @param context       Test context
   2596  * @param name          Test case's name
   2597  * @param description   Test case's description
   2598  **/
   2599 GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest(
   2600 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   2601 	: GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description)
   2602 {
   2603 	/* Nothing to be done here */
   2604 }
   2605 
   2606 /** Get wrap mode for texture
   2607  *
   2608  *  @param out_wrap_mode Wrap mode
   2609  **/
   2610 void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode)
   2611 {
   2612 	out_wrap_mode = m_glExtTokens.CLAMP_TO_BORDER;
   2613 }
   2614 
   2615 /** Provides names of varyings to be captured by test
   2616  *
   2617  * @param out_captured_varyings Vector of varyings' names
   2618  **/
   2619 void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::getVaryings(
   2620 	std::vector<const glw::GLchar*>& out_captured_varyings)
   2621 {
   2622 	out_captured_varyings.push_back("without_offset");
   2623 	out_captured_varyings.push_back("with_offset");
   2624 	out_captured_varyings.push_back("floor_tex_coord");
   2625 }
   2626 
   2627 /** Get parts of vertex shader
   2628  *
   2629  *  @param out_vertex_shader_parts Vector of vertex shader parts
   2630  **/
   2631 void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::getShaderParts(
   2632 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   2633 {
   2634 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   2635 }
   2636 
   2637 /** Prepare test specific data, that will be used as vertex attributes
   2638  *
   2639  *  @param vertex_buffer_infos Vector of vertexBufferInfo instances
   2640  **/
   2641 void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::prepareVertexBuffersData(
   2642 	std::vector<VertexBufferInfo>& vertex_buffer_infos)
   2643 {
   2644 	/* Constats for offsets and size of buffer */
   2645 	const unsigned int n_total_components = m_n_vertices * m_n_offsets_components;
   2646 
   2647 	/* Limits used to generate offsets */
   2648 	const glw::GLint min_ptgo = m_min_texture_gather_offset;
   2649 	const glw::GLint max_ptgo = m_max_texture_gather_offset;
   2650 
   2651 	/* Storage for offsets */
   2652 	m_offsets_buffer_data.resize(n_total_components);
   2653 
   2654 	/* Generate offsets */
   2655 	for (unsigned int i = 0; i < n_total_components; ++i)
   2656 	{
   2657 		if (0 == i % 2)
   2658 		{
   2659 			m_offsets_buffer_data[i] = (rand() % (max_ptgo - min_ptgo + 1)) + min_ptgo;
   2660 		}
   2661 		else
   2662 		{
   2663 			/* y offsets must be set to 0*/
   2664 			m_offsets_buffer_data[i] = 0;
   2665 		}
   2666 	}
   2667 
   2668 	/* Setup offsets VB info */
   2669 	VertexBufferInfo info;
   2670 
   2671 	info.attribute_name = m_offsets_attribute_name;
   2672 	info.n_components   = m_n_offsets_components;
   2673 	info.type			= GL_INT;
   2674 	info.data			= &m_offsets_buffer_data[0];
   2675 	info.data_size		= (glw::GLuint)(m_offsets_buffer_data.size() * sizeof(glw::GLint));
   2676 
   2677 	/* Add VB info to vector */
   2678 	vertex_buffer_infos.push_back(info);
   2679 }
   2680 
   2681 /** Check if data captured for vertex at index are as expected
   2682  *
   2683  *  @param captured_data Instance of capturedVaryings for vertex at index
   2684  *  @param index         Index of vertex
   2685  *  @param texture_size  Size of texture
   2686  *
   2687  *  @return True  Results match expected values
   2688  *          False Results do not match expected values
   2689  **/
   2690 bool GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::checkResult(const CapturedVaryings& captured_data,
   2691 																			unsigned int			index,
   2692 																			unsigned int			texture_size)
   2693 {
   2694 	/* Get offsets for vertex */
   2695 	glw::GLint x_offset;
   2696 	glw::GLint y_offset;
   2697 
   2698 	getOffsets(x_offset, y_offset, index);
   2699 
   2700 	/* Storage for expected values of with_offset varyings */
   2701 	glw::GLint expected_values[m_n_components_per_varying];
   2702 
   2703 	/* Index of first not clamped texel in without_offset set*/
   2704 	int not_clamped_texel_index = -1;
   2705 
   2706 	/* X offsets of texels in 2x2 set */
   2707 	static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 };
   2708 
   2709 	/* Find first not clamped texel in without_offset set */
   2710 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2711 	{
   2712 		if ((int)texture_size != captured_data.without_offset[i])
   2713 		{
   2714 			not_clamped_texel_index = i;
   2715 			break;
   2716 		}
   2717 	}
   2718 
   2719 	if (-1 == not_clamped_texel_index)
   2720 	{
   2721 		/* Log problem with sampler */
   2722 		m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", "");
   2723 
   2724 		logCoordinates(index);
   2725 
   2726 		m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   2727 
   2728 		m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   2729 						   << tcu::TestLog::EndMessage;
   2730 
   2731 		logVaryings(captured_data);
   2732 
   2733 		m_testCtx.getLog() << tcu::TestLog::EndSection;
   2734 
   2735 		TCU_FAIL("Unexpected sampling results");
   2736 	}
   2737 
   2738 	/* Fraction part of position for lower left texel without_offset set */
   2739 	const glw::GLint fract_position_x =
   2740 		captured_data.without_offset[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index];
   2741 
   2742 	/* Absolute position of lower left corner in without_offset set */
   2743 	const glw::GLint absolute_position_x = fract_position_x + captured_data.floor_tex_coord[0] * (int)texture_size;
   2744 
   2745 	/* Wraping matrix */
   2746 	glw::GLint wrap_matrix[4] = { 0 };
   2747 
   2748 	/* Index of value in without_offset set, that should be check for being clamped */
   2749 	glw::GLint wrap_value_to_check_indices[4] = { 3, 2, 1, 0 };
   2750 
   2751 	/* Get value from without_offset to check for clamping */
   2752 	glw::GLint wrap_value_to_check = captured_data.without_offset[wrap_value_to_check_indices[not_clamped_texel_index]];
   2753 
   2754 	/* Setup wrap_matrix */
   2755 	switch (not_clamped_texel_index)
   2756 	{
   2757 	case 0:
   2758 	case 1:
   2759 		wrap_matrix[0] = 0;
   2760 		wrap_matrix[1] = 0;
   2761 
   2762 		if ((glw::GLint)texture_size == wrap_value_to_check)
   2763 		{
   2764 			wrap_matrix[2] = -1;
   2765 			wrap_matrix[3] = -1;
   2766 		}
   2767 		break;
   2768 	case 2:
   2769 	case 3:
   2770 		wrap_matrix[2] = 0;
   2771 		wrap_matrix[3] = 0;
   2772 
   2773 		if ((glw::GLint)texture_size == wrap_value_to_check)
   2774 		{
   2775 			wrap_matrix[0] = 1;
   2776 			wrap_matrix[1] = 1;
   2777 		}
   2778 		break;
   2779 	};
   2780 
   2781 	/* Apply integral part of texture coordinates to wrap_matrix */
   2782 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2783 	{
   2784 		wrap_matrix[i] += captured_data.floor_tex_coord[1];
   2785 	}
   2786 
   2787 	/* For each texel in without_offset set calculate absolute position and apply offset */
   2788 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2789 	{
   2790 		expected_values[i] = absolute_position_x + gather_offsets_x[i];
   2791 		expected_values[i] += x_offset;
   2792 
   2793 		/* Set to texture_size when point is outside of texture */
   2794 		if ((0 > expected_values[i]) || (((glw::GLint)texture_size) < expected_values[i]) || (0 != wrap_matrix[i]))
   2795 		{
   2796 			expected_values[i] = texture_size;
   2797 		}
   2798 	}
   2799 
   2800 	/* Verify that expected_values match those in with_offset varyings */
   2801 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2802 	{
   2803 		if (captured_data.with_offset[i] != expected_values[i])
   2804 		{
   2805 			/* Log invalid results */
   2806 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   2807 
   2808 			logCoordinates(index);
   2809 
   2810 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   2811 
   2812 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   2813 							   << tcu::TestLog::EndMessage;
   2814 
   2815 			logVaryings(captured_data);
   2816 
   2817 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   2818 
   2819 			/* Done */
   2820 			return false;
   2821 		}
   2822 	}
   2823 
   2824 	/* Done */
   2825 	return true;
   2826 }
   2827 
   2828 /** Initializes GLES objects used during the test.
   2829  *
   2830  */
   2831 void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::initTest(void)
   2832 {
   2833 	/* Check if texture_border_clamp extension is supported */
   2834 	if (!m_is_texture_border_clamp_supported)
   2835 	{
   2836 		throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__);
   2837 	}
   2838 
   2839 	GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::initTest();
   2840 }
   2841 
   2842 /** Constructor
   2843  *
   2844  * @param context       Test context
   2845  * @param name          Test case's name
   2846  * @param description   Test case's description
   2847  **/
   2848 GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest(
   2849 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   2850 	: GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description)
   2851 {
   2852 	/* Nothing to be done here */
   2853 }
   2854 
   2855 /** Get wrap mode for texture
   2856  *
   2857  *  @param out_wrap_mode Wrap mode
   2858  **/
   2859 void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode)
   2860 {
   2861 	out_wrap_mode = GL_CLAMP_TO_EDGE;
   2862 }
   2863 
   2864 /** Get parts of vertex shader
   2865  *
   2866  *  @param out_vertex_shader_parts Vector of vertex shader parts
   2867  **/
   2868 void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::getShaderParts(
   2869 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   2870 {
   2871 	out_vertex_shader_parts.push_back(m_vertex_shader_code);
   2872 }
   2873 
   2874 /** Check if data captured for vertex at index are as expected
   2875  *
   2876  *  @param captured_data Instance of capturedVaryings for vertex at index
   2877  *  @param index         Index of vertex
   2878  *  @param texture_size  Size of texture
   2879  *
   2880  *  @return True  Results match expected values
   2881  *          False Results do not match expected values
   2882  **/
   2883 bool GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::checkResult(const CapturedVaryings& captured_data,
   2884 																		  unsigned int index, unsigned int texture_size)
   2885 {
   2886 	/* Get offsets for vertex */
   2887 	glw::GLint x_offset;
   2888 	glw::GLint y_offset;
   2889 
   2890 	getOffsets(x_offset, y_offset, index);
   2891 
   2892 	/* Storage for expected values of with_offset varyings */
   2893 	glw::GLint expected_values[m_n_components_per_varying];
   2894 
   2895 	/* Index of first not clamped texel in without_offset set*/
   2896 	int not_clamped_texel_index = -1;
   2897 
   2898 	/* X offsets of texels in 2x2 set */
   2899 	static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 };
   2900 
   2901 	/* Find first not clamped texel in without_offset set */
   2902 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2903 	{
   2904 		if ((int)texture_size != captured_data.without_offset[i])
   2905 		{
   2906 			not_clamped_texel_index = i;
   2907 			break;
   2908 		}
   2909 	}
   2910 
   2911 	if (-1 == not_clamped_texel_index)
   2912 	{
   2913 		/* Log problem with sampler */
   2914 		m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", "");
   2915 
   2916 		logCoordinates(index);
   2917 
   2918 		m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   2919 
   2920 		m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   2921 						   << tcu::TestLog::EndMessage;
   2922 
   2923 		logVaryings(captured_data);
   2924 
   2925 		m_testCtx.getLog() << tcu::TestLog::EndSection;
   2926 
   2927 		TCU_FAIL("Unexpected sampling results");
   2928 	}
   2929 
   2930 	/* Fraction part of position for lower left texel without_offset set */
   2931 	const glw::GLint fract_position_x =
   2932 		captured_data.without_offset[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index];
   2933 
   2934 	/* Absolute position of lower left corner in without_offset set */
   2935 	const glw::GLint absolute_position_x = fract_position_x + captured_data.floor_tex_coord[0] * (int)texture_size;
   2936 
   2937 	/* Calculate expected values of with_offset varyings */
   2938 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2939 	{
   2940 		expected_values[i] = absolute_position_x + gather_offsets_x[i];
   2941 		expected_values[i] += x_offset;
   2942 
   2943 		/* Clamp when point is outside of texture */
   2944 		clamp(expected_values[i], 0, ((glw::GLint)texture_size) - 1);
   2945 	}
   2946 
   2947 	/* Verify that expected_values match those in with_offset varyings */
   2948 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   2949 	{
   2950 		if (captured_data.with_offset[i] != expected_values[i])
   2951 		{
   2952 			/* Log invalid results */
   2953 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   2954 
   2955 			logCoordinates(index);
   2956 
   2957 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   2958 
   2959 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset
   2960 							   << tcu::TestLog::EndMessage;
   2961 
   2962 			logVaryings(captured_data);
   2963 
   2964 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   2965 
   2966 			/* Done */
   2967 			return false;
   2968 		}
   2969 	}
   2970 
   2971 	/* Done */
   2972 	return true;
   2973 }
   2974 
   2975 /** Provides names of varyings to be captured by test
   2976  *
   2977  * @param out_captured_varyings Vector of varyings' names
   2978  **/
   2979 void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::getVaryings(
   2980 	std::vector<const glw::GLchar*>& out_captured_varyings)
   2981 {
   2982 	out_captured_varyings.push_back("without_offset");
   2983 	out_captured_varyings.push_back("with_offset");
   2984 	out_captured_varyings.push_back("floor_tex_coord");
   2985 }
   2986 
   2987 /** Initializes GLES objects used during the test.
   2988  *
   2989  */
   2990 void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::initTest(void)
   2991 {
   2992 	/* Check if texture_border_clamp extension is supported */
   2993 	if (!m_is_texture_border_clamp_supported)
   2994 	{
   2995 		throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__);
   2996 	}
   2997 
   2998 	GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::initTest();
   2999 }
   3000 
   3001 /** Constructor
   3002  *
   3003  * @param context       Test context
   3004  * @param name          Test case's name
   3005  * @param description   Test case's description
   3006  **/
   3007 GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest(
   3008 	Context& context, const ExtParameters& extParams, const char* name, const char* description)
   3009 	: GPUShader5TextureGatherOffsetDepthTestBase(context, extParams, name, description)
   3010 {
   3011 	/* Nothing to be done here */
   3012 }
   3013 
   3014 /** Get parts of vertex shader
   3015  *
   3016  *  @param out_vertex_shader_parts Vector of vertex shader parts
   3017  **/
   3018 void GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::getShaderParts(
   3019 	std::vector<const glw::GLchar*>& out_vertex_shader_parts)
   3020 {
   3021 	std::stringstream stream;
   3022 
   3023 	stream << "           ivec2[4]( ivec2( " << m_min_texture_gather_offset << ", " << m_min_texture_gather_offset
   3024 		   << "),\n";
   3025 	stream << "                     ivec2( " << m_min_texture_gather_offset << ", " << m_max_texture_gather_offset
   3026 		   << "),\n";
   3027 	stream << "                     ivec2( " << m_max_texture_gather_offset << ", " << m_min_texture_gather_offset
   3028 		   << "),\n";
   3029 	stream << "                     ivec2( " << m_max_texture_gather_offset << ", " << m_max_texture_gather_offset
   3030 		   << "));\n";
   3031 
   3032 	m_vertex_shader_code_offsets = stream.str();
   3033 
   3034 	out_vertex_shader_parts.push_back(m_vertex_shader_code_preamble);
   3035 	out_vertex_shader_parts.push_back(m_vertex_shader_code_offsets.c_str());
   3036 	out_vertex_shader_parts.push_back(m_vertex_shader_code_body);
   3037 }
   3038 
   3039 /** Prepare test specific data, that will be used as vertex attributes
   3040  *
   3041  *  @param vertex_buffer_infos Vector of vertexBufferInfo instances
   3042  **/
   3043 void GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::prepareVertexBuffersData(
   3044 	std::vector<VertexBufferInfo>& vertex_buffer_infos)
   3045 {
   3046 	DE_UNREF(vertex_buffer_infos);
   3047 
   3048 	/* Nothing to be done here */
   3049 }
   3050 
   3051 /** Check if data captured for vertex at index are as expected
   3052  *
   3053  *  @param captured_data Instance of capturedVaryings for vertex at index
   3054  *  @param index         Index of vertex
   3055  *  @param texture_size  Size of texture
   3056  *
   3057  *  @return True  Results match expected values
   3058  *          False Results do not match expected values
   3059  **/
   3060 bool GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::checkResult(const CapturedVaryings& captured_data,
   3061 																	  unsigned int index, unsigned int tex_size)
   3062 {
   3063 	/* Signed int value has to be used with operator % in order to work as expected */
   3064 	const glw::GLint texture_size = (glw::GLint)tex_size;
   3065 
   3066 	/* X and Y offsets */
   3067 	glw::GLint x_offsets[m_n_components_per_varying] = {
   3068 		m_min_texture_gather_offset, m_min_texture_gather_offset, m_max_texture_gather_offset,
   3069 		m_max_texture_gather_offset,
   3070 	};
   3071 
   3072 	glw::GLint y_offsets[m_n_components_per_varying] = {
   3073 		m_min_texture_gather_offset, m_max_texture_gather_offset, m_min_texture_gather_offset,
   3074 		m_max_texture_gather_offset,
   3075 	};
   3076 
   3077 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   3078 	{
   3079 		/* Roll x offsets around left edge when negative */
   3080 		if (0 > x_offsets[i])
   3081 		{
   3082 			x_offsets[i] = x_offsets[i] % texture_size;
   3083 			x_offsets[i] += texture_size;
   3084 		}
   3085 	}
   3086 
   3087 	/* Storage for expected values of with_offset varyings */
   3088 	glw::GLint expected_values[m_n_components_per_varying];
   3089 
   3090 	/* Calculate expected values of with_offset varyings */
   3091 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   3092 	{
   3093 		expected_values[i] = ((x_offsets[i] + captured_data.without_offset[3]) % texture_size);
   3094 	}
   3095 
   3096 	/* Verify that expected_values match those in with_offset varyings */
   3097 	for (unsigned int i = 0; i < m_n_components_per_varying; ++i)
   3098 	{
   3099 		if (captured_data.with_offset[i] != expected_values[i])
   3100 		{
   3101 			/* Log invalid results */
   3102 			m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", "");
   3103 
   3104 			logCoordinates(index);
   3105 
   3106 			m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage;
   3107 
   3108 			m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: "
   3109 							   << "(" << x_offsets[0] << ", " << y_offsets[0] << ") "
   3110 							   << "(" << x_offsets[1] << ", " << y_offsets[1] << ") "
   3111 							   << "(" << x_offsets[2] << ", " << y_offsets[2] << ") "
   3112 							   << "(" << x_offsets[3] << ", " << y_offsets[3] << ") " << tcu::TestLog::EndMessage;
   3113 
   3114 			logVaryings(captured_data);
   3115 
   3116 			m_testCtx.getLog() << tcu::TestLog::EndSection;
   3117 
   3118 			/* Done */
   3119 			return false;
   3120 		}
   3121 	}
   3122 
   3123 	/* Done */
   3124 	return true;
   3125 }
   3126 
   3127 } /* glcts */
   3128