external/openglcts/modules/gl/gl4cEnhancedLayoutsTests.hpp

   1 #ifndef _GL4CENHANCEDLAYOUTSTESTS_HPP
   2 #define _GL4CENHANCEDLAYOUTSTESTS_HPP
   3 /*-------------------------------------------------------------------------
   4  * OpenGL Conformance Test Suite
   5  * -----------------------------
   6  *
   7  * Copyright (c) 2015-2016 The Khronos Group Inc.
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */ /*!
  22  * \file
  23  * \brief
  24  */ /*-------------------------------------------------------------------*/
  25
  26 /**
  27  * \file  gl4cEnhancedLayoutsTests.hpp
  28  * \brief Declares test classes for "Enhanced Layouts" functionality.
  29  */ /*-------------------------------------------------------------------*/
  30
  31 #include "glcTestCase.hpp"
  32 #include "glwDefs.hpp"
  33
  34 namespace tcu
  35 {
  36 class MessageBuilder;
  37 } /* namespace tcu */
  38
  39 namespace gl4cts
  40 {
  41
  42 namespace EnhancedLayouts
  43 {
  44 namespace Utils
  45 {
  46 /** Represents data type
  47  *
  48  **/
  49 struct Type
  50 {
  51 public:
  52         enum TYPES
  53         {
  54                 Float,
  55                 Double,
  56                 Int,
  57                 Uint,
  58         };
  59
  60         /* Public methods */
  61         /* Functionality */
  62         std::vector<glw::GLubyte> GenerateData() const;
  63         std::vector<glw::GLubyte> GenerateDataPacked() const;
  64         glw::GLuint GetActualAlignment(glw::GLuint align, bool is_array) const;
  65         glw::GLuint GetBaseAlignment(bool is_array) const;
  66         std::string GetGLSLConstructor(const glw::GLvoid* data) const;
  67         const glw::GLchar* GetGLSLTypeName() const;
  68         glw::GLuint GetLocations(bool is_vs_input = false) const;
  69         glw::GLuint GetSize(const bool is_std140 = false) const;
  70         glw::GLenum GetTypeGLenum() const;
  71         glw::GLuint GetNumComponents() const;
  72
  73         /* Public static routines */
  74         /* Functionality */
  75         static glw::GLuint CalculateStd140Stride(glw::GLuint alignment, glw::GLuint n_columns,
  76                                                                                          glw::GLuint n_array_elements);
  77
  78         static bool DoesTypeSupportMatrix(TYPES type);
  79
  80         static glw::GLuint GetActualOffset(glw::GLuint start_offset, glw::GLuint actual_alignment);
  81
  82         static Type GetType(TYPES basic_type, glw::GLuint n_columns, glw::GLuint n_rows);
  83
  84         static glw::GLuint GetTypeSize(TYPES type);
  85
  86         /* GL gets */
  87         static glw::GLenum GetTypeGLenum(TYPES type);
  88
  89         /* Public fields */
  90         TYPES           m_basic_type;
  91         glw::GLuint m_n_columns;
  92         glw::GLuint m_n_rows;
  93
  94         /* Public constants */
  95         static const Type _double;
  96         static const Type dmat2;
  97         static const Type dmat2x3;
  98         static const Type dmat2x4;
  99         static const Type dmat3x2;
 100         static const Type dmat3;
 101         static const Type dmat3x4;
 102         static const Type dmat4x2;
 103         static const Type dmat4x3;
 104         static const Type dmat4;
 105         static const Type dvec2;
 106         static const Type dvec3;
 107         static const Type dvec4;
 108         static const Type _float;
 109         static const Type _int;
 110         static const Type ivec2;
 111         static const Type ivec3;
 112         static const Type ivec4;
 113         static const Type mat2;
 114         static const Type mat2x3;
 115         static const Type mat2x4;
 116         static const Type mat3x2;
 117         static const Type mat3;
 118         static const Type mat3x4;
 119         static const Type mat4x2;
 120         static const Type mat4x3;
 121         static const Type mat4;
 122         static const Type vec2;
 123         static const Type vec3;
 124         static const Type vec4;
 125         static const Type uint;
 126         static const Type uvec2;
 127         static const Type uvec3;
 128         static const Type uvec4;
 129 };
 130
 131 /** Represents buffer instance
 132  * Provides basic buffer functionality
 133  **/
 134 class Buffer
 135 {
 136 public:
 137         /* Public enums */
 138         enum BUFFERS
 139         {
 140                 Array,
 141                 Element,
 142                 Shader_Storage,
 143                 Texture,
 144                 Transform_feedback,
 145                 Uniform,
 146         };
 147
 148         enum USAGE
 149         {
 150                 DynamicCopy,
 151                 DynamicDraw,
 152                 DynamicRead,
 153                 StaticCopy,
 154                 StaticDraw,
 155                 StaticRead,
 156                 StreamCopy,
 157                 StreamDraw,
 158                 StreamRead,
 159         };
 160
 161         enum ACCESS
 162         {
 163                 ReadOnly,
 164                 WriteOnly,
 165                 ReadWrite,
 166         };
 167
 168         /* Public methods */
 169         /* Ctr & Dtr */
 170         Buffer(deqp::Context& context);
 171         ~Buffer();
 172
 173         /* Init & Release */
 174         void Init(BUFFERS buffer, USAGE usage, glw::GLsizeiptr size, glw::GLvoid* data);
 175         void Release();
 176
 177         /* Functionality */
 178         void Bind() const;
 179         void BindBase(glw::GLuint index) const;
 180
 181         void BindRange(glw::GLuint index, glw::GLintptr offset, glw::GLsizeiptr size) const;
 182
 183         void Data(USAGE usage, glw::GLsizeiptr size, glw::GLvoid* data);
 184
 185         glw::GLvoid* Map(ACCESS access);
 186
 187         void SubData(glw::GLintptr offset, glw::GLsizeiptr size, glw::GLvoid* data);
 188
 189         void UnMap();
 190
 191         /* Public static routines */
 192         /* Functionality */
 193         static void Bind(const glw::Functions& gl, glw::GLuint id, BUFFERS buffer);
 194
 195         static void BindBase(const glw::Functions& gl, glw::GLuint id, BUFFERS buffer, glw::GLuint index);
 196
 197         static void BindRange(const glw::Functions& gl, glw::GLuint id, BUFFERS buffer, glw::GLuint index,
 198                                                   glw::GLintptr offset, glw::GLsizeiptr size);
 199
 200         static void Data(const glw::Functions& gl, BUFFERS buffer, USAGE usage, glw::GLsizeiptr size, glw::GLvoid* data);
 201
 202         static void Generate(const glw::Functions& gl, glw::GLuint& out_id);
 203
 204         static void* Map(const glw::Functions& gl, BUFFERS buffer, ACCESS access);
 205
 206         static void SubData(const glw::Functions& gl, BUFFERS buffer, glw::GLintptr offset, glw::GLsizeiptr size,
 207                                                 glw::GLvoid* data);
 208
 209         static void UnMap(const glw::Functions& gl, BUFFERS buffer);
 210
 211         /* GL gets */
 212         static glw::GLenum GetAccessGLenum(ACCESS access);
 213         static glw::GLenum GetBufferGLenum(BUFFERS buffer);
 214         static glw::GLenum GetUsageGLenum(USAGE usage);
 215
 216         /* Gets */
 217         static const glw::GLchar* GetBufferName(BUFFERS buffer);
 218
 219         /* Public fields */
 220         glw::GLuint m_id;
 221
 222         /* Public constants */
 223         static const glw::GLuint m_invalid_id;
 224
 225         /* Buffer type maybe changed for different cases*/
 226         BUFFERS m_buffer;
 227
 228 private:
 229         /* Private fields */
 230         deqp::Context& m_context;
 231 };
 232
 233 /** Represents framebuffer
 234  * Provides basic functionality
 235  **/
 236 class Framebuffer
 237 {
 238 public:
 239         /* Public methods */
 240         /* Ctr & Dtr */
 241         Framebuffer(deqp::Context& context);
 242         ~Framebuffer();
 243
 244         /* Init & Release */
 245         void Init();
 246         void Release();
 247
 248         /* Functionality */
 249         void AttachTexture(glw::GLenum attachment, glw::GLuint texture_id, glw::GLuint width, glw::GLuint height);
 250
 251         void Bind();
 252         void Clear(glw::GLenum mask);
 253
 254         void ClearColor(glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat alpha);
 255
 256         /* Public static routines */
 257         static void AttachTexture(const glw::Functions& gl, glw::GLenum attachment, glw::GLuint texture_id,
 258                                                           glw::GLuint width, glw::GLuint height);
 259
 260         static void Bind(const glw::Functions& gl, glw::GLuint id);
 261
 262         static void Clear(const glw::Functions& gl, glw::GLenum mask);
 263
 264         static void ClearColor(const glw::Functions& gl, glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue,
 265                                                    glw::GLfloat alpha);
 266
 267         static void Generate(const glw::Functions& gl, glw::GLuint& out_id);
 268
 269         /* Public fields */
 270         glw::GLuint m_id;
 271
 272         /* Public constants */
 273         static const glw::GLuint m_invalid_id;
 274
 275 private:
 276         /* Private fields */
 277         deqp::Context& m_context;
 278 };
 279
 280 /** Represents shader instance.
 281  * Provides basic functionality for shaders.
 282  **/
 283 class Shader
 284 {
 285 public:
 286         /* Public enums */
 287         enum STAGES
 288         {
 289                 COMPUTE = 0,
 290                 VERTEX,
 291                 TESS_CTRL,
 292                 TESS_EVAL,
 293                 GEOMETRY,
 294                 FRAGMENT,
 295
 296                 /* */
 297                 STAGE_MAX
 298         };
 299
 300         /* Public types */
 301
 302         class InvalidSourceException : public std::exception
 303         {
 304         public:
 305                 InvalidSourceException(const glw::GLchar* error_message, const std::string& source, STAGES stage);
 306
 307                 virtual ~InvalidSourceException() throw()
 308                 {
 309                 }
 310
 311                 virtual const char* what() const throw();
 312
 313                 void log(deqp::Context& context) const;
 314
 315                 std::string m_message;
 316                 std::string m_source;
 317                 STAGES          m_stage;
 318         };
 319
 320         /* Public methods */
 321         /* Ctr & Dtr */
 322         Shader(deqp::Context& context);
 323         ~Shader();
 324
 325         /* Init & Realese */
 326         void Init(STAGES stage, const std::string& source);
 327         void Release();
 328
 329         /* Public static routines */
 330         /* Functionality */
 331         static void Compile(const glw::Functions& gl, glw::GLuint id);
 332
 333         static void Create(const glw::Functions& gl, STAGES stage, glw::GLuint& out_id);
 334
 335         static void Source(const glw::Functions& gl, glw::GLuint id, const std::string& source);
 336
 337         /* GL gets */
 338         static glw::GLenum GetShaderStageGLenum(STAGES stage);
 339
 340         /* Get stage name */
 341         static const glw::GLchar* GetStageName(STAGES stage);
 342
 343         /* Logs sources */
 344         static void LogSource(deqp::Context& context, const std::string& source, STAGES stage);
 345
 346         /* Public fields */
 347         glw::GLuint m_id;
 348
 349         /* Public constants */
 350         static const glw::GLuint m_invalid_id;
 351
 352 private:
 353         /* Private types */
 354         class CompilationException : public std::exception
 355         {
 356         public:
 357                 CompilationException(const glw::GLchar* message);
 358
 359                 virtual ~CompilationException() throw()
 360                 {
 361                 }
 362
 363                 virtual const char* what() const throw();
 364
 365                 std::string m_message;
 366         };
 367
 368         /* Private fields */
 369         deqp::Context& m_context;
 370 };
 371
 372 /* Forward declaration */
 373 struct Interface;
 374
 375 /** Represents GLSL variable
 376  *
 377  **/
 378 struct Variable
 379 {
 380 public:
 381         /* Typedefs */
 382         typedef std::vector<Variable>  Vector;
 383         typedef std::vector<Variable*> PtrVector;
 384
 385         /* Enums */
 386         enum STORAGE
 387         {
 388                 VARYING_INPUT,
 389                 VARYING_OUTPUT,
 390                 UNIFORM,
 391                 SSB,
 392                 MEMBER,
 393
 394                 /* */
 395                 STORAGE_MAX
 396         };
 397
 398         enum VARYING_DIRECTION
 399         {
 400                 INPUT,
 401                 OUTPUT,
 402         };
 403
 404         enum FLAVOUR
 405         {
 406                 BASIC,
 407                 ARRAY,
 408                 INDEXED_BY_INVOCATION_ID,
 409         };
 410
 411         /**/
 412         enum TYPE
 413         {
 414                 BUILTIN,
 415                 INTERFACE,
 416         };
 417
 418         /* Types */
 419         struct Descriptor
 420         {
 421                 /* */
 422                 typedef std::vector<Descriptor> Vector;
 423
 424                 /* */
 425                 Descriptor(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component,
 426                                    glw::GLint expected_location, const Type& type, glw::GLboolean normalized,
 427                                    glw::GLuint n_array_elements, glw::GLint expected_stride_of_element, glw::GLuint offset);
 428
 429                 Descriptor(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_componenet,
 430                                    glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements,
 431                                    glw::GLint expected_stride_of_element, glw::GLuint offset);
 432
 433                 /* */
 434                 std::string GetDefinition(FLAVOUR flavour, STORAGE storage) const;
 435
 436                 /* */
 437                 glw::GLint       m_expected_component;
 438                 glw::GLint       m_expected_location;
 439                 glw::GLint       m_expected_stride_of_element;
 440                 glw::GLuint     m_n_array_elements;
 441                 std::string     m_name;
 442                 glw::GLboolean m_normalized;
 443                 glw::GLuint     m_offset;
 444                 std::string     m_qualifiers;
 445
 446                 TYPE m_type;
 447                 union {
 448                         Type       m_builtin;
 449                         Interface* m_interface;
 450                 };
 451         };
 452
 453         /* Constructors */
 454         template <typename T>
 455         Variable(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component,
 456                          glw::GLint expected_location, const Type& type, glw::GLboolean normalized, glw::GLuint n_array_elements,
 457                          glw::GLint expected_stride_of_element, glw::GLuint offset, const T* data, size_t data_size,
 458                          STORAGE storage)
 459                 : m_data((glw::GLvoid*)data)
 460                 , m_data_size(data_size)
 461                 , m_descriptor(name, qualifiers, expected_component, expected_location, type, normalized, n_array_elements,
 462                                            expected_stride_of_element, offset)
 463                 , m_storage(storage)
 464         {
 465         }
 466
 467         template <typename T>
 468         Variable(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component,
 469                          glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements,
 470                          glw::GLint expected_stride_of_element, glw::GLuint offset, const T* data, size_t data_size,
 471                          STORAGE storage)
 472                 : m_data((glw::GLvoid*)data)
 473                 , m_data_size(data_size)
 474                 , m_descriptor(name, qualifiers, expected_component, expected_location, interface, n_array_elements,
 475                                            expected_stride_of_element, offset)
 476                 , m_storage(storage)
 477         {
 478         }
 479
 480         Variable(const Variable& var);
 481
 482         /* Functionality */
 483         std::string GetDefinition(FLAVOUR flavour) const;
 484         glw::GLuint GetSize() const;
 485         glw::GLuint GetStride() const;
 486         bool            IsBlock() const;
 487         bool            IsStruct() const;
 488         /* Static routines */
 489         static FLAVOUR GetFlavour(Shader::STAGES stage, VARYING_DIRECTION direction);
 490         static std::string GetReference(const std::string& parent_name, const Descriptor& variable, FLAVOUR flavour,
 491                                                                         glw::GLuint array_index);
 492
 493         /* Fields */
 494         glw::GLvoid* m_data;
 495         size_t           m_data_size;
 496         Descriptor   m_descriptor;
 497         STORAGE          m_storage;
 498
 499         /* Constants */
 500         static const glw::GLint m_automatic_location;
 501 };
 502
 503 /* Define the methods NAME, that will add new variable to VECTOR with STORAGE set               */
 504 #define DEFINE_VARIABLE_CLASS(NAME, STORAGE, VECTOR)                                                                  \
 505         template <typename T>                                                                                             \
 506         Variable* NAME(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component,             \
 507                                    glw::GLint expected_location, const Type& type, glw::GLboolean normalized,                         \
 508                                    glw::GLuint n_array_elements, glw::GLint expected_stride_of_element, glw::GLuint offset,           \
 509                                    const T* data, size_t data_size)                                                                   \
 510         {                                                                                                                 \
 511                 Variable* var = new Variable(name, qualifiers, expected_component, expected_location, type, normalized,       \
 512                                                                          n_array_elements, expected_stride_of_element, offset, data, data_size, STORAGE); \
 513                 if (0 == var)                                                                                                 \
 514                 {                                                                                                             \
 515                         TCU_FAIL("Memory allocation");                                                                            \
 516                 }                                                                                                             \
 517                 VECTOR.push_back(var);                                                                                        \
 518                 return VECTOR.back();                                                                                         \
 519         }                                                                                                                 \
 520                                                                                                                       \
 521         template <typename T>                                                                                             \
 522         Variable* NAME(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component,             \
 523                                    glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements,                  \
 524                                    glw::GLint expected_stride_of_element, glw::GLuint offset, const T* data, size_t data_size)        \
 525         {                                                                                                                 \
 526                 Variable* var = new Variable(name, qualifiers, expected_component, expected_location, interface,              \
 527                                                                          n_array_elements, expected_stride_of_element, offset, data, data_size, STORAGE); \
 528                 if (0 == var)                                                                                                 \
 529                 {                                                                                                             \
 530                         TCU_FAIL("Memory allocation");                                                                            \
 531                 }                                                                                                             \
 532                 VECTOR.push_back(var);                                                                                        \
 533                 return VECTOR.back();                                                                                         \
 534         }
 535
 536 /** Represents structures and block
 537  *
 538  **/
 539 struct Interface
 540 {
 541 public:
 542         /* Typedefs */
 543         typedef std::vector<Interface>  Vector;
 544         typedef std::vector<Interface*> PtrVector;
 545
 546         /**/
 547         enum TYPE
 548         {
 549                 STRUCT,
 550                 BLOCK
 551         };
 552
 553         /* Constructor */
 554         Interface(const glw::GLchar* name, TYPE type);
 555
 556         /*  */
 557         Variable::Descriptor* Member(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component,
 558                                                                  glw::GLint expected_location, const Type& type, glw::GLboolean normalized,
 559                                                                  glw::GLuint n_array_elements, glw::GLint expected_stride_of_element,
 560                                                                  glw::GLuint offset);
 561         Variable::Descriptor* Member(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component,
 562                                                                  glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements,
 563                                                                  glw::GLint expected_stride_of_element, glw::GLuint offset);
 564
 565         /**/
 566         Variable::Descriptor* AddMember(const Variable::Descriptor& member);
 567
 568         std::string GetDefinition() const;
 569
 570         /**/
 571         Variable::Descriptor::Vector m_members;
 572         std::string                                      m_name;
 573         TYPE                                             m_type;
 574 };
 575
 576 struct ShaderInterface
 577 {
 578         ShaderInterface(Shader::STAGES stage);
 579
 580         DEFINE_VARIABLE_CLASS(Input, Variable::VARYING_INPUT, m_inputs);
 581         DEFINE_VARIABLE_CLASS(Output, Variable::VARYING_OUTPUT, m_outputs);
 582         DEFINE_VARIABLE_CLASS(Uniform, Variable::UNIFORM, m_uniforms);
 583         DEFINE_VARIABLE_CLASS(SSB, Variable::SSB, m_ssb_blocks);
 584
 585         /**/
 586         std::string GetDefinitionsGlobals() const;
 587         std::string GetDefinitionsInputs() const;
 588         std::string GetDefinitionsOutputs() const;
 589         std::string GetDefinitionsSSBs() const;
 590         std::string GetDefinitionsUniforms() const;
 591
 592         std::string                     m_globals;
 593         Variable::PtrVector m_inputs;
 594         Variable::PtrVector m_outputs;
 595         Variable::PtrVector m_uniforms;
 596         Variable::PtrVector m_ssb_blocks;
 597
 598         Shader::STAGES m_stage;
 599 };
 600
 601 struct VaryingConnection
 602 {
 603         /* */
 604         typedef std::vector<VaryingConnection> Vector;
 605
 606         /* */
 607         VaryingConnection(Variable* in, Variable* out);
 608
 609         /* */
 610         Variable* m_in;
 611         Variable* m_out;
 612 };
 613
 614 struct VaryingPassthrough
 615 {
 616         /* */
 617         void Add(Shader::STAGES stage, Variable* in, Variable* out);
 618
 619         VaryingConnection::Vector& Get(Shader::STAGES stage);
 620
 621         /**/
 622         VaryingConnection::Vector m_fragment;
 623         VaryingConnection::Vector m_geometry;
 624         VaryingConnection::Vector m_tess_ctrl;
 625         VaryingConnection::Vector m_tess_eval;
 626         VaryingConnection::Vector m_vertex;
 627 };
 628
 629 struct ProgramInterface
 630 {
 631
 632         /* */
 633         ProgramInterface();
 634         ~ProgramInterface();
 635
 636         /* */
 637         Interface* AddInterface(const glw::GLchar* name, Interface::TYPE type);
 638         Interface* Block(const glw::GLchar* name);
 639         Interface* GetBlock(const glw::GLchar* name);
 640         ShaderInterface& GetShaderInterface(Shader::STAGES stage);
 641         const ShaderInterface& GetShaderInterface(Shader::STAGES stage) const;
 642         Interface* GetStructure(const glw::GLchar* name);
 643         Interface* Structure(const glw::GLchar* name);
 644
 645         /**/
 646         std::string GetDefinitionsStructures() const;
 647         std::string GetInterfaceForStage(Shader::STAGES stage) const;
 648
 649         /* */
 650         Interface* CloneBlockForStage(const Interface& block, Shader::STAGES stage, Variable::STORAGE storage,
 651                                                                   const glw::GLchar* prefix);
 652         void CloneVertexInterface(VaryingPassthrough& variable_pass);
 653
 654         /* */
 655         static const glw::GLchar* GetStagePrefix(Shader::STAGES stage, Variable::STORAGE storage);
 656
 657         /* */
 658         Interface::PtrVector m_structures;
 659         Interface::PtrVector m_blocks;
 660
 661         ShaderInterface m_compute;
 662         ShaderInterface m_vertex;
 663         ShaderInterface m_tess_ctrl;
 664         ShaderInterface m_tess_eval;
 665         ShaderInterface m_geometry;
 666         ShaderInterface m_fragment;
 667
 668         //Variable::Vector     m_fragment_outputs;
 669         //Variable::PtrVector  m_captured_varyings;
 670
 671 private:
 672         /* */
 673         void cloneVariableForStage(const Variable& variable, Shader::STAGES stage, const glw::GLchar* prefix,
 674                                                            VaryingPassthrough& varying_passthrough);
 675         Variable* cloneVariableForStage(const Variable& variable, Shader::STAGES stage, Variable::STORAGE storage,
 676                                                                         const glw::GLchar* prefix);
 677         void replaceBinding(Variable& variable, Shader::STAGES stage);
 678 };
 679
 680 /** Represents program pipeline
 681  *
 682  **/
 683 class Pipeline
 684 {
 685 public:
 686         /* Public methods */
 687         /* Ctr & Dtr */
 688         Pipeline(deqp::Context& context);
 689         ~Pipeline();
 690
 691         /* Init & Release */
 692         void Init();
 693         void Release();
 694
 695         /* Functionality */
 696         void Bind();
 697         void UseProgramStages(glw::GLuint program_id, glw::GLenum stages);
 698
 699         /* Public static routines */
 700         /* Functionality */
 701         void Bind(const glw::Functions& gl, glw::GLuint id);
 702         void UseProgramStages(const glw::Functions& gl, glw::GLuint id, glw::GLuint program_id, glw::GLenum stages);
 703
 704         /* Public fields */
 705         glw::GLuint m_id;
 706
 707         /* Public constants */
 708         static const glw::GLuint m_invalid_id;
 709
 710 private:
 711         /* Private fields */
 712         deqp::Context& m_context;
 713 };
 714
 715 /** Represents program instance.
 716  * Provides basic functionality
 717  **/
 718 class Program
 719 {
 720 public:
 721         /* Public types */
 722         class BuildException : public std::exception
 723         {
 724         public:
 725                 BuildException(const glw::GLchar* error_message, const std::string compute_shader,
 726                                            const std::string fragment_shader, const std::string geometry_shader,
 727                                            const std::string tess_ctrl_shader, const std::string tess_eval_shader,
 728                                            const std::string vertex_shader);
 729                 virtual ~BuildException() throw()
 730                 {
 731                 }
 732
 733                 virtual const char* what() const throw();
 734
 735                 void log(deqp::Context& context) const;
 736
 737                 std::string m_error_message;
 738                 std::string m_compute_shader;
 739                 std::string m_fragment_shader;
 740                 std::string m_geometry_shader;
 741                 std::string m_tess_ctrl_shader;
 742                 std::string m_tess_eval_shader;
 743                 std::string m_vertex_shader;
 744         };
 745
 746         typedef std::vector<std::string> NameVector;
 747
 748         /* Public methods */
 749         /* Ctr & Dtr */
 750         Program(deqp::Context& context);
 751         ~Program();
 752
 753         /* Init & Release */
 754         void Init(const std::string& compute_shader, const std::string& fragment_shader, const std::string& geometry_shader,
 755                           const std::string& tessellation_control_shader, const std::string& tessellation_evaluation_shader,
 756                           const std::string& vertex_shader, const NameVector& captured_varyings, bool capture_interleaved,
 757                           bool is_separable);
 758
 759         void Init(const std::string& compute_shader, const std::string& fragment_shader, const std::string& geometry_shader,
 760                           const std::string& tessellation_control_shader, const std::string& tessellation_evaluation_shader,
 761                           const std::string& vertex_shader, bool is_separable);
 762
 763         void Release();
 764
 765         /* Functionality */
 766         void GetActiveUniformsiv(glw::GLsizei count, const glw::GLuint* indices, glw::GLenum pname,
 767                                                          glw::GLint* params) const;
 768
 769         glw::GLint GetAttribLocation(const std::string& name) const;
 770
 771         void GetResource(glw::GLenum interface, glw::GLuint index, glw::GLenum property, glw::GLsizei buf_size,
 772                                          glw::GLint* params) const;
 773
 774         glw::GLuint GetResourceIndex(const std::string& name, glw::GLenum interface) const;
 775
 776         void GetUniformIndices(glw::GLsizei count, const glw::GLchar** names, glw::GLuint* indices) const;
 777
 778         glw::GLint GetUniformLocation(const std::string& name) const;
 779         void Use() const;
 780
 781         /* Public static routines */
 782         /* Functionality */
 783         static void Attach(const glw::Functions& gl, glw::GLuint program_id, glw::GLuint shader_id);
 784
 785         static void Capture(const glw::Functions& gl, glw::GLuint id, const NameVector& captured_varyings,
 786                                                 bool capture_interleaved);
 787
 788         static void Create(const glw::Functions& gl, glw::GLuint& out_id);
 789
 790         static void GetActiveUniformsiv(const glw::Functions& gl, glw::GLuint program_id, glw::GLsizei count,
 791                                                                         const glw::GLuint* indices, glw::GLenum pname, glw::GLint* params);
 792
 793         static void GetUniformIndices(const glw::Functions& gl, glw::GLuint program_id, glw::GLsizei count,
 794                                                                   const glw::GLchar** names, glw::GLuint* indices);
 795
 796         static void Link(const glw::Functions& gl, glw::GLuint id);
 797
 798         static void Uniform(const glw::Functions& gl, const Type& type, glw::GLsizei count, glw::GLint location,
 799                                                 const glw::GLvoid* data);
 800
 801         static void Use(const glw::Functions& gl, glw::GLuint id);
 802
 803         /* Get locations */
 804         static glw::GLint GetAttribLocation(const glw::Functions& gl, glw::GLuint id, const std::string& name);
 805
 806         static void GetResource(const glw::Functions& gl, glw::GLuint id, glw::GLenum interface, glw::GLuint index,
 807                                                         glw::GLenum property, glw::GLsizei buf_size, glw::GLint* params);
 808
 809         static glw::GLuint GetResourceIndex(const glw::Functions& gl, glw::GLuint id, const std::string& name,
 810                                                                                 glw::GLenum interface);
 811
 812         static glw::GLint GetUniformLocation(const glw::Functions& gl, glw::GLuint id, const std::string& name);
 813
 814         /* Public fields */
 815         glw::GLuint m_id;
 816
 817         Shader m_compute;
 818         Shader m_fragment;
 819         Shader m_geometry;
 820         Shader m_tess_ctrl;
 821         Shader m_tess_eval;
 822         Shader m_vertex;
 823
 824         /* Public constants */
 825         static const glw::GLuint m_invalid_id;
 826
 827 private:
 828         /* Private types */
 829         class LinkageException : public std::exception
 830         {
 831         public:
 832                 LinkageException(const glw::GLchar* error_message);
 833
 834                 virtual ~LinkageException() throw()
 835                 {
 836                 }
 837
 838                 virtual const char* what() const throw();
 839
 840                 std::string m_error_message;
 841         };
 842
 843         /* Private fields */
 844         deqp::Context& m_context;
 845 };
 846
 847 class Texture
 848 {
 849 public:
 850         /* Public enums */
 851         enum TYPES
 852         {
 853                 TEX_BUFFER,
 854                 TEX_2D,
 855                 TEX_2D_RECT,
 856                 TEX_2D_ARRAY,
 857                 TEX_3D,
 858                 TEX_CUBE,
 859                 TEX_1D,
 860                 TEX_1D_ARRAY,
 861         };
 862
 863         /* Public methods */
 864         /* Ctr & Dtr */
 865         Texture(deqp::Context& context);
 866         ~Texture();
 867
 868         /* Init & Release */
 869         void Init(TYPES tex_type, glw::GLuint width, glw::GLuint height, glw::GLuint depth, glw::GLenum internal_format,
 870                           glw::GLenum format, glw::GLenum type, glw::GLvoid* data);
 871
 872         void Init(glw::GLenum internal_format, glw::GLuint buffer_id);
 873
 874         void Release();
 875
 876         /* Functionality */
 877         void Bind() const;
 878         void Get(glw::GLenum format, glw::GLenum type, glw::GLvoid* out_data) const;
 879
 880         /* Public static routines */
 881         /* Functionality */
 882         static void Bind(const glw::Functions& gl, glw::GLuint id, TYPES tex_type);
 883
 884         static void Generate(const glw::Functions& gl, glw::GLuint& out_id);
 885
 886         static void Get(const glw::Functions& gl, TYPES tex_type, glw::GLenum format, glw::GLenum type,
 887                                         glw::GLvoid* out_data);
 888
 889         static void Storage(const glw::Functions& gl, TYPES tex_type, glw::GLuint width, glw::GLuint height,
 890                                                 glw::GLuint depth, glw::GLenum internal_format);
 891
 892         static void TexBuffer(const glw::Functions& gl, glw::GLenum internal_format, glw::GLuint& buffer_id);
 893
 894         static void Update(const glw::Functions& gl, TYPES tex_type, glw::GLuint width, glw::GLuint height,
 895                                            glw::GLuint depth, glw::GLenum format, glw::GLenum type, glw::GLvoid* data);
 896
 897         /* GL gets */
 898         static glw::GLenum GetTargetGLenum(TYPES tex_type);
 899
 900         /* Public fields */
 901         glw::GLuint m_id;
 902
 903         /* Public constants */
 904         static const glw::GLuint m_invalid_id;
 905
 906 private:
 907         deqp::Context& m_context;
 908         TYPES              m_type;
 909 };
 910
 911 /** Represents Vertex array object
 912  * Provides basic functionality
 913  **/
 914 class VertexArray
 915 {
 916 public:
 917         /* Public methods */
 918         /* Ctr & Dtr */
 919         VertexArray(deqp::Context& Context);
 920         ~VertexArray();
 921
 922         /* Init & Release */
 923         void Init();
 924         //void Init(const ProgramInterface& program_interface,
 925         //                glw::GLuint       vertex_buffer,
 926         //                glw::GLuint       index_buffer);
 927         void Release();
 928
 929         void Attribute(glw::GLuint index, const Type& type, glw::GLuint n_array_elements, glw::GLboolean normalized,
 930                                    glw::GLsizei stride, const glw::GLvoid* pointer);
 931
 932         void Bind();
 933
 934         /* Public static methods */
 935         static void AttribPointer(const glw::Functions& gl, glw::GLuint index, const Type& type,
 936                                                           glw::GLuint n_array_elements, glw::GLboolean normalized, glw::GLsizei stride,
 937                                                           const glw::GLvoid* pointer);
 938
 939         static void Bind(const glw::Functions& gl, glw::GLuint id);
 940
 941         static void Disable(const glw::Functions& gl, glw::GLuint index, const Type& type, glw::GLuint n_array_elements);
 942
 943         static void Divisor(const glw::Functions& gl, glw::GLuint index, glw::GLuint divisor);
 944
 945         static void Enable(const glw::Functions& gl, glw::GLuint index, const Type& type, glw::GLuint n_array_elements);
 946
 947         static void Generate(const glw::Functions& gl, glw::GLuint& out_id);
 948
 949         /* Public fields */
 950         glw::GLuint m_id;
 951
 952         /* Public constants */
 953         static const glw::GLuint m_invalid_id;
 954
 955 private:
 956         deqp::Context& m_context;
 957 };
 958
 959 /* UniformN*v prototypes */
 960 typedef GLW_APICALL void(GLW_APIENTRY* uniformNdv)(glw::GLint, glw::GLsizei, const glw::GLdouble*);
 961 typedef GLW_APICALL void(GLW_APIENTRY* uniformNfv)(glw::GLint, glw::GLsizei, const glw::GLfloat*);
 962 typedef GLW_APICALL void(GLW_APIENTRY* uniformNiv)(glw::GLint, glw::GLsizei, const glw::GLint*);
 963 typedef GLW_APICALL void(GLW_APIENTRY* uniformNuiv)(glw::GLint, glw::GLsizei, const glw::GLuint*);
 964 typedef GLW_APICALL void(GLW_APIENTRY* uniformMatrixNdv)(glw::GLint, glw::GLsizei, glw::GLboolean,
 965                                                                                                                  const glw::GLdouble*);
 966 typedef GLW_APICALL void(GLW_APIENTRY* uniformMatrixNfv)(glw::GLint, glw::GLsizei, glw::GLboolean, const glw::GLfloat*);
 967
 968 /* Public static methods */
 969 /* UniformN*v routine getters */
 970 uniformNdv getUniformNdv(const glw::Functions& gl, glw::GLuint n_rows);
 971 uniformNfv getUniformNfv(const glw::Functions& gl, glw::GLuint n_rows);
 972 uniformNiv getUniformNiv(const glw::Functions& gl, glw::GLuint n_rows);
 973 uniformNuiv getUniformNuiv(const glw::Functions& gl, glw::GLuint n_rows);
 974 uniformMatrixNdv getUniformMatrixNdv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows);
 975 uniformMatrixNfv getUniformMatrixNfv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows);
 976
 977 /* Stuff */
 978 bool checkProgramInterface(const ProgramInterface& program_interface, Program& program, std::stringstream& stream);
 979
 980 bool isExtensionSupported(deqp::Context& context, const glw::GLchar* extension_name);
 981
 982 bool isGLVersionAtLeast(const glw::Functions& gl, glw::GLint required_major, glw::GLint required_minor);
 983
 984 void replaceToken(const glw::GLchar* token, size_t& search_position, const glw::GLchar* text, std::string& string);
 985
 986 void replaceAllTokens(const glw::GLchar* token, const glw::GLchar* text, std::string& string);
 987
 988 glw::GLuint roundUpToPowerOf2(glw::GLuint value);
 989
 990 void insertElementOfList(const glw::GLchar* element, const glw::GLchar* separator, size_t& search_position,
 991                                                  std::string& string);
 992
 993 void endList(const glw::GLchar* separator, size_t& search_position, std::string& string);
 994 } /* Utils namespace */
 995
 996 /** Base class for tests **/
 997 class TestBase : public deqp::TestCase
 998 {
 999 public:
1000         /* Public methods */
1001         TestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);
1002
1003         virtual ~TestBase()
1004         {
1005         }
1006
1007         /* Public methods inherited from TestCase */
1008         virtual tcu::TestNode::IterateResult iterate(void);
1009
1010 protected:
1011         /* Methods to be implemented by child class */
1012         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1013         virtual glw::GLuint getTestCaseNumber();
1014         virtual bool testCase(glw::GLuint test_case_index) = 0;
1015         virtual void testInit();
1016
1017         /* Routines avaiable for children */
1018         glw::GLuint calculateStride(const Utils::Interface& interface) const;
1019         void generateData(const Utils::Interface& interface, glw::GLuint offset, std::vector<glw::GLubyte>& out_data) const;
1020
1021         glw::GLint getLastInputLocation(Utils::Shader::STAGES stage, const Utils::Type& type, glw::GLuint array_lenth);
1022
1023         glw::GLint getLastOutputLocation(Utils::Shader::STAGES stage, const Utils::Type& type, glw::GLuint array_lenth);
1024
1025         Utils::Type getType(glw::GLuint index) const;
1026         std::string getTypeName(glw::GLuint index) const;
1027         glw::GLuint getTypesNumber() const;
1028
1029         bool isFlatRequired(Utils::Shader::STAGES stage, const Utils::Type& type, Utils::Variable::STORAGE storage) const;
1030
1031 private:
1032         /* Private methods */
1033         bool test();
1034 };
1035
1036 /** Base class for test doing Buffer alghorithm **/
1037 class BufferTestBase : public TestBase
1038 {
1039 public:
1040         /* Public methods */
1041         BufferTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);
1042
1043         virtual ~BufferTestBase()
1044         {
1045         }
1046
1047 protected:
1048         /* */
1049         struct bufferDescriptor
1050         {
1051                 /* Typedefs */
1052                 typedef std::vector<bufferDescriptor> Vector;
1053
1054                 /* Fileds */
1055                 std::vector<glw::GLubyte> m_expected_data;
1056                 std::vector<glw::GLubyte> m_initial_data;
1057                 glw::GLuint                               m_index;
1058                 Utils::Buffer::BUFFERS  m_target;
1059
1060                 /* Constants */
1061                 static const glw::GLuint m_non_indexed;
1062         };
1063
1064         class bufferCollection
1065         {
1066         public:
1067                 struct pair
1068                 {
1069                         Utils::Buffer*  m_buffer;
1070                         bufferDescriptor* m_descriptor;
1071                 };
1072
1073                 ~bufferCollection();
1074
1075                 typedef std::vector<pair> Vector;
1076
1077                 Vector m_vector;
1078         };
1079
1080         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
1081
1082         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
1083
1084         virtual void getCapturedVaryings(glw::GLuint test_case_index, Utils::Program::NameVector& captured_varyings, glw::GLint* xfb_components);
1085
1086         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
1087                                                            std::string& out_calculations);
1088
1089         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
1090                                                                         std::string& out_interface);
1091
1092         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1093
1094         virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream);
1095
1096         virtual bool testCase(glw::GLuint test_case_index);
1097         virtual bool verifyBuffers(bufferCollection& buffers);
1098
1099 private:
1100         void            cleanBuffers();
1101         std::string getShaderTemplate(Utils::Shader::STAGES stage);
1102         void prepareBuffer(Utils::Buffer& buffer, bufferDescriptor& descriptor);
1103         void prepareBuffers(bufferDescriptor::Vector& descriptors, bufferCollection& out_buffers);
1104
1105         /* */
1106 };
1107
1108 class NegativeTestBase : public TestBase
1109 {
1110 public:
1111         /* Public methods */
1112         NegativeTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);
1113
1114         virtual ~NegativeTestBase()
1115         {
1116         }
1117
1118 protected:
1119         /* Methods to be implemented by child class */
1120         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage) = 0;
1121         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1122         virtual bool isFailureExpected(glw::GLuint test_case_index);
1123         virtual bool testCase(glw::GLuint test_case_index);
1124 };
1125
1126 /** Base class for test doing Texture alghorithm **/
1127 class TextureTestBase : public TestBase
1128 {
1129 public:
1130         /* Public methods */
1131         TextureTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);
1132
1133         virtual ~TextureTestBase()
1134         {
1135         }
1136
1137 protected:
1138         /* Methods to be implemented by child class */
1139         virtual bool checkResults(glw::GLuint test_case_index, Utils::Texture& color_0);
1140
1141         virtual void executeDispatchCall(glw::GLuint test_case_index);
1142         virtual void executeDrawCall(glw::GLuint test_case_index);
1143
1144         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1145                                                                          Utils::VaryingPassthrough& varying_passthrough);
1146
1147         virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough,
1148                                                                            Utils::Shader::STAGES stage);
1149
1150         virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1151                                                                                            Utils::Shader::STAGES stage);
1152
1153         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1154         virtual bool isDrawRelevant(glw::GLuint test_case_index);
1155
1156         virtual void prepareAttributes(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1157                                                                    Utils::Buffer& buffer, Utils::VertexArray& vao);
1158
1159         virtual void prepareAttribLocation(Utils::Program& program, Utils::ProgramInterface& program_interface);
1160
1161         virtual void prepareFragmentDataLoc(Utils::Program& program, Utils::ProgramInterface& program_interface);
1162
1163         virtual void prepareFramebuffer(Utils::Framebuffer& framebuffer, Utils::Texture& color_0_texture);
1164
1165         virtual void prepareImage(glw::GLint location, Utils::Texture& image_texture) const;
1166
1167         virtual void prepareSSBs(glw::GLuint test_case_index, Utils::ShaderInterface& si, Utils::Program& program,
1168                                                          Utils::Buffer& buffer);
1169
1170         virtual void prepareSSBs(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1171                                                          Utils::Program& program, Utils::Buffer& cs_buffer);
1172
1173         virtual void prepareSSBs(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1174                                                          Utils::Program& program, Utils::Buffer& fs_buffer, Utils::Buffer& gs_buffer,
1175                                                          Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer, Utils::Buffer& vs_buffer);
1176
1177         virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ShaderInterface& si, Utils::Program& program,
1178                                                                  Utils::Buffer& buffer);
1179
1180         virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1181                                                                  Utils::Program& program, Utils::Buffer& cs_buffer);
1182
1183         virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1184                                                                  Utils::Program& program, Utils::Buffer& fs_buffer, Utils::Buffer& gs_buffer,
1185                                                                  Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer, Utils::Buffer& vs_buffer);
1186
1187         virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1188                                                                  Utils::Program& fs_program, Utils::Program& gs_program, Utils::Program& tcs_program,
1189                                                                  Utils::Program& tes_program, Utils::Program& vs_program, Utils::Buffer& fs_buffer,
1190                                                                  Utils::Buffer& gs_buffer, Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer,
1191                                                                  Utils::Buffer& vs_buffer);
1192         //virtual void        prepareDrawPrograms   (glw::GLuint                 test_case_index,
1193         //                                           Utils::Program&             fragment,
1194         //                                           Utils::Program&             geometry,
1195         //                                           Utils::Program&             tess_ctrl,
1196         //                                           Utils::Program&             tess_eval,
1197         //                                           Utils::Program&             vertex);
1198         virtual bool testCase(glw::GLuint test_case_index);
1199         virtual bool testMonolithic(glw::GLuint test_case_index);
1200         virtual bool testSeparable(glw::GLuint test_case_index);
1201         virtual bool useComponentQualifier(glw::GLuint test_case_index);
1202         virtual bool useMonolithicProgram(glw::GLuint test_case_index);
1203
1204         /* Protected constants */
1205         static const glw::GLuint m_width;
1206         static const glw::GLuint m_height;
1207
1208 private:
1209         std::string getShaderSource(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1210                                                                 Utils::VaryingPassthrough& varying_passthrough, Utils::Shader::STAGES stage);
1211
1212         const glw::GLchar* getShaderTemplate(Utils::Shader::STAGES stage);
1213
1214         std::string getVariablePassthrough(const std::string&                             in_parent_name,
1215                                                                            const Utils::Variable::Descriptor& in_variable,
1216                                                                            Utils::Variable::FLAVOUR in_flavour, const std::string& out_parent_name,
1217                                                                            const Utils::Variable::Descriptor& out_variable,
1218                                                                            Utils::Variable::FLAVOUR                       out_flavour);
1219
1220         std::string getVariableVerification(const std::string& parent_name, const glw::GLvoid* data,
1221                                                                                 const Utils::Variable::Descriptor& variable, Utils::Variable::FLAVOUR flavour);
1222
1223         void prepareSSB(Utils::Program& program, Utils::Variable& variable, Utils::Buffer& buffer);
1224
1225         void prepareUniform(Utils::Program& program, Utils::Variable& variable, Utils::Buffer& buffer);
1226 };
1227
1228 /** Implementation of test APIConstantValues. Description follows:
1229  *
1230  *  Test verifies values of the following constants are at least as specified:
1231  * - MAX_TRANSFORM_FEEDBACK_BUFFERS                - 4,
1232  * - MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS - 64.
1233  **/
1234 class APIConstantValuesTest : public deqp::TestCase
1235 {
1236 public:
1237         /* Public methods */
1238         APIConstantValuesTest(deqp::Context& context);
1239         virtual ~APIConstantValuesTest()
1240         {
1241         }
1242
1243         /* Public methods inherited from TestCase */
1244         virtual tcu::TestNode::IterateResult iterate(void);
1245 };
1246
1247 /** Implementation of test APIErrors. Description follows:
1248  *
1249  * Test verifies that errors are generated as specified:
1250  * - GetProgramInterfaceiv should generate INVALID_OPERATION when
1251  * <programInterface> is TRANSFORM_FEEDBACK_BUFFER and <pname> is
1252  * MAX_NAME_LENGTH;
1253  * - GetProgramResourceIndex should generate INVALID_ENUM when
1254  * <programInterface> is TRANSFORM_FEEDBACK_BUFFER;
1255  * - GetProgramResourceName should generate INVALID_ENUM when
1256  * <programInterface> is TRANSFORM_FEEDBACK_BUFFER;
1257  **/
1258 class APIErrorsTest : public deqp::TestCase
1259 {
1260 public:
1261         /* Public methods */
1262         APIErrorsTest(deqp::Context& context);
1263         virtual ~APIErrorsTest()
1264         {
1265         }
1266
1267         /* Public methods inherited from TestCase */
1268         virtual tcu::TestNode::IterateResult iterate(void);
1269
1270 private:
1271         void checkError(glw::GLenum expected_error, const glw::GLchar* message, bool& test_result);
1272 };
1273
1274 /** Implementation of test GLSLContantValues. Description follows:
1275  *
1276  * Test verifies values of the following symbols:
1277  *
1278  *     GL_ARB_enhanced_layouts,
1279  *     gl_MaxTransformFeedbackBuffers,
1280  *     gl_MaxTransformFeedbackInterleavedComponents.
1281  *
1282  * This test implements Texture algorithm. Test following code snippet:
1283  *
1284  *     if (1 != GL_ARB_enhanced_layouts)
1285  *     {
1286  *         result = 0;
1287  *     }
1288  *     else if (MAX_TRANSFORM_FEEDBACK_BUFFERS
1289  *         != gl_MaxTransformFeedbackBuffers)
1290  *     {
1291  *         result = 0;
1292  *     }
1293  *     else if (MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS
1294  *         != gl_MaxTransformFeedbackInterleavedComponents)
1295  *     {
1296  *         result = 0;
1297  *     }
1298  **/
1299 class GLSLContantValuesTest : public TextureTestBase
1300 {
1301 public:
1302         GLSLContantValuesTest(deqp::Context& context);
1303         ~GLSLContantValuesTest()
1304         {
1305         }
1306
1307 protected:
1308         virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1309                                                                                            Utils::Shader::STAGES stage);
1310
1311         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1312 };
1313
1314 /** Implementation of test GLSLContantImmutablity. Description follows:
1315  *
1316  * Test verifies that values of the following symbols cannot be changed in
1317  * shader:
1318  *
1319  *     GL_ARB_enhanced_layouts,
1320  *     gl_MaxTransformFeedbackBuffers,
1321  *     gl_MaxTransformFeedbackInterleavedComponents.
1322  *
1323  * Compile following code snippet:
1324  *
1325  *     CONSTANT = 3;
1326  *
1327  * It is expected that compilation will fail. Test each shader stage
1328  * separately. Test each constant separately.
1329  **/
1330 class GLSLContantImmutablityTest : public NegativeTestBase
1331 {
1332 public:
1333         /* Public methods */
1334         GLSLContantImmutablityTest(deqp::Context& context);
1335
1336         virtual ~GLSLContantImmutablityTest()
1337         {
1338         }
1339
1340 protected:
1341         /* Methods to be implemented by child class */
1342         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1343
1344         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1345         virtual glw::GLuint getTestCaseNumber();
1346         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1347         virtual void testInit();
1348
1349 private:
1350         /* Private enums */
1351         enum CONSTANTS
1352         {
1353                 GL_ARB_ENHANCED_LAYOUTS,
1354                 GL_MAX_XFB,
1355                 GL_MAX_XFB_INT_COMP,
1356
1357                 /* */
1358                 CONSTANTS_MAX,
1359         };
1360
1361         /* Private types */
1362         struct testCase
1363         {
1364                 CONSTANTS                         m_constant;
1365                 Utils::Shader::STAGES m_stage;
1366         };
1367
1368         /* Private methods */
1369         const glw::GLchar* getConstantName(CONSTANTS constant);
1370
1371         /* Private fields */
1372         std::vector<testCase> m_test_cases;
1373 };
1374
1375 /** Implementation of test GLSLConstantIntegralExpression. Description follows:
1376  *
1377  * Check that following symbols can be used as integral constant expressions:
1378  *
1379  *     GL_ARB_enhanced_layouts,
1380  *     gl_MaxTransformFeedbackBuffers,
1381  *     gl_MaxTransformFeedbackInterleavedComponents.
1382  *
1383  * Test implement Texture algorithm. Test following code snippet:
1384  *
1385  *     uniform uint goku [GL_ARB_enhanced_layouts / GOKU_DIV];
1386  *     uniform uint gohan[gl_MaxTransformFeedbackBuffers / GOHAN_DIV];
1387  *     uniform uint goten[gl_MaxTransformFeedbackInterleavedComponents /
1388  *                         GOTEN_DIV];
1389  *
1390  *     for (i = 0; i < goku.length; ++i)
1391  *         goku_sum += goku[i];
1392  *
1393  *     for (i = 0; i < gohan.length; ++i)
1394  *         gohan_sum += gohan[i];
1395  *
1396  *     for (i = 0; i < goten.length; ++i)
1397  *         goten_sum += goten[i];
1398  *
1399  *     if ( (expected_goku_sum  == goku_sum)  &&
1400  *          (expected_gohan_sum == gohan_sum) &&
1401  *          (expected_goten_sum == goten_sum) )
1402  *         result = 1;
1403  *     else
1404  *         result = 0;
1405  *
1406  * Select DIV values so as array lengths are below 16.
1407  **/
1408 class GLSLConstantIntegralExpressionTest : public TextureTestBase
1409 {
1410 public:
1411         /* Public methods */
1412         GLSLConstantIntegralExpressionTest(deqp::Context& context);
1413
1414         virtual ~GLSLConstantIntegralExpressionTest()
1415         {
1416         }
1417
1418 protected:
1419         /* Protected methods */
1420         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1421                                                                          Utils::VaryingPassthrough& varying_passthrough);
1422
1423         virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1424                                                                                            Utils::Shader::STAGES stage);
1425
1426         virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1427                                                                  Utils::Program& program, Utils::Buffer& cs_buffer);
1428
1429         virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1430                                                                  Utils::Program& program, Utils::Buffer& fs_buffer, Utils::Buffer& gs_buffer,
1431                                                                  Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer, Utils::Buffer& vs_buffer);
1432
1433 private:
1434         glw::GLint m_gohan_length;
1435         glw::GLint m_goten_length;
1436 };
1437
1438 /** Implementation of test UniformBlockMemberOffsetAndAlign. Description follows:
1439  *
1440  * Test verifies that:
1441  *     - offset and align qualifiers are respected for uniform block members,
1442  *     - align qualifier is ignored if value is too small,
1443  *     - align qualifier accepts values bigger than size of base type,
1444  *     - manual and automatic offsets and alignments can be mixed.
1445  *
1446  * This test implement Texture algorithm. Test following code snippet:
1447  *
1448  *     const int basic_size = sizeof(basic_type_of(type));
1449  *     const int type_size  = sizeof(type);
1450  *     const int type_align = roundUpToPowerOf2(type_size);
1451  *
1452  *     layout (std140, offset = 0) uniform Block {
1453  *         layout(align = 8 * basic_size)  type at_first_offset;
1454  *         layout(offset = type_size, align = basic_size / 2)
1455  *                                         type at_second_offset;
1456  *         layout(align = 2 * type_align)  type at_third_offset;
1457  *         layout(offset = 3 * type_align + type_size)
1458  *                                         type at_fourth_offset;
1459  *                                         type at_fifth_offset;
1460  *                                         type at_sixth_offset[2];
1461  *         layout(align = 8 * basic_size)  type at_eight_offset;
1462  *     };
1463  *
1464  *     if ( (at_first_offset  == at_eight_offset   ) &&
1465  *          (at_second_offset == at_sixth_offset[1]) &&
1466  *          (at_third_offset  == at_sixth_offset[0]) &&
1467  *          (at_fourth_offset == at_fifth_offset   ) )
1468  *         result = 1;
1469  *     else
1470  *         result = 0;
1471  *
1472  * Additionally inspect program to verify that all block members:
1473  * - are reported,
1474  * - have correct offsets.
1475  *
1476  * Test should be executed for all types.
1477  **/
1478 class UniformBlockMemberOffsetAndAlignTest : public TextureTestBase
1479 {
1480 public:
1481         /* Public methods */
1482         UniformBlockMemberOffsetAndAlignTest(deqp::Context& context);
1483
1484         virtual ~UniformBlockMemberOffsetAndAlignTest()
1485         {
1486         }
1487
1488 protected:
1489         /* Protected methods */
1490         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1491                                                                          Utils::VaryingPassthrough& varying_passthrough);
1492
1493         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1494         virtual glw::GLuint getTestCaseNumber();
1495
1496         virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1497                                                                                            Utils::Shader::STAGES stage);
1498
1499 private:
1500         std::vector<glw::GLubyte> m_data;
1501 };
1502
1503 /** Implementation of test UniformBlockLayoutQualifierConflict. Description follows:
1504  *
1505  * Test verifies that offset and align can only be used on members of blocks
1506  * declared as std140.
1507  *
1508  * Test following code snippet with all shader stages:
1509  *
1510  *     layout(QUALIFIER) uniform Block {
1511  *         layout(offset = 16) vec4 boy;
1512  *         layout(align  = 48) vec4 man;
1513  *     };
1514  *
1515  * Test following block qualifiers and all types:
1516  *
1517  *     default - meaning not declared by shader
1518  *     std140,
1519  *     shared,
1520  *     packed.
1521  *
1522  * Qualifier std430 is not allowed for uniform blocks.
1523  *
1524  * Test expect that only case using std140 will compile and link successfully,
1525  * while the rest will fail to compile or link.
1526  **/
1527 class UniformBlockLayoutQualifierConflictTest : public NegativeTestBase
1528 {
1529 public:
1530         /* Public methods */
1531         UniformBlockLayoutQualifierConflictTest(deqp::Context& context);
1532
1533         virtual ~UniformBlockLayoutQualifierConflictTest()
1534         {
1535         }
1536
1537 protected:
1538         /* Methods to be implemented by child class */
1539         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1540
1541         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1542         virtual glw::GLuint getTestCaseNumber();
1543
1544         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1545         virtual bool isFailureExpected(glw::GLuint test_case_index);
1546         virtual void testInit();
1547
1548 private:
1549         /* Private enums */
1550         enum QUALIFIERS
1551         {
1552                 DEFAULT,
1553                 STD140,
1554                 SHARED,
1555                 PACKED,
1556
1557                 /* */
1558                 QUALIFIERS_MAX,
1559         };
1560
1561         /* Private types */
1562         struct testCase
1563         {
1564                 QUALIFIERS                        m_qualifier;
1565                 Utils::Shader::STAGES m_stage;
1566         };
1567
1568         /* Private methods */
1569         const glw::GLchar* getQualifierName(QUALIFIERS qualifier);
1570
1571         /* Private fields */
1572         std::vector<testCase> m_test_cases;
1573 };
1574
1575 /** Implementation of test UniformBlockMemberInvalidOffsetAlignment. Description follows:
1576  *
1577  * Test verifies that offset alignment rules are enforced.
1578  *
1579  * Declare uniform block, which contains following member declaration:
1580  *
1581  *     layout(offset = X) type block_member
1582  *
1583  * Shader compilation is expected to fail for any X that is not a multiple of
1584  * the base alignment of type.
1585  * Test all offsets covering locations first and one before last:
1586  *
1587  *     <0, sizeof(type)>
1588  *     <MAX_UNIFORM_BLOCK_SIZE - 2 * sizeof(type),
1589  *         MAX_UNIFORM_BLOCK_SIZE - sizeof(type)>
1590  *
1591  * Test all shader stages. Test all types. Each case should be tested
1592  * separately.
1593  **/
1594 class UniformBlockMemberInvalidOffsetAlignmentTest : public NegativeTestBase
1595 {
1596 public:
1597         /* Public methods */
1598         UniformBlockMemberInvalidOffsetAlignmentTest(deqp::Context& context);
1599
1600         UniformBlockMemberInvalidOffsetAlignmentTest(deqp::Context& context, const glw::GLchar* name,
1601                                                                                                  const glw::GLchar* description);
1602
1603         virtual ~UniformBlockMemberInvalidOffsetAlignmentTest()
1604         {
1605         }
1606
1607 protected:
1608         /* Methods to be implemented by child class */
1609         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1610
1611         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1612         virtual glw::GLuint getTestCaseNumber();
1613         virtual glw::GLint  getMaxBlockSize();
1614         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1615         virtual bool isFailureExpected(glw::GLuint test_case_index);
1616         virtual bool isStageSupported(Utils::Shader::STAGES stage);
1617         virtual void testInit();
1618
1619 protected:
1620         /* Protected types */
1621         struct testCase
1622         {
1623                 glw::GLuint                       m_offset;
1624                 bool                              m_should_fail;
1625                 Utils::Shader::STAGES m_stage;
1626                 Utils::Type                       m_type;
1627         };
1628
1629         /* Protected fields */
1630         std::vector<testCase> m_test_cases;
1631 };
1632
1633 /** Implementation of test UniformBlockMemberOverlappingOffsets. Description follows:
1634  *
1635  * Test verifies that block members cannot overlap.
1636  *
1637  * Use following code snippet:
1638  *
1639  *     layout (std140) uniform Block {
1640  *         layout (offset = boy_offset) boy_type boy;
1641  *         layout (offset = man_offset) man_type man;
1642  *     };
1643  *
1644  * It is expected that overlapping members will cause compilation failure.
1645  *
1646  * There are three cases to test:
1647  *
1648  *     - when member is declared with the same offset as already declared
1649  *     member,
1650  *     - when member is declared with offset that lay in the middle of already
1651  *     declared member,
1652  *     - when member is declared with offset just before already declared
1653  *     member and there is not enough space.
1654  *
1655  * Test all shader stages. Test all types. Test cases separately.
1656  *
1657  * Note that not all type combinations let to test all three cases, e.g.
1658  * vec4 and float.
1659  **/
1660 class UniformBlockMemberOverlappingOffsetsTest : public NegativeTestBase
1661 {
1662 public:
1663         /* Public methods */
1664         UniformBlockMemberOverlappingOffsetsTest(deqp::Context& context);
1665
1666         UniformBlockMemberOverlappingOffsetsTest(deqp::Context& context, const glw::GLchar* name,
1667                                                                                          const glw::GLchar* description);
1668
1669         virtual ~UniformBlockMemberOverlappingOffsetsTest()
1670         {
1671         }
1672
1673 protected:
1674         /* Methods to be implemented by child class */
1675         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1676
1677         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1678         virtual glw::GLuint getTestCaseNumber();
1679         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1680         virtual bool isStageSupported(Utils::Shader::STAGES stage);
1681         virtual void testInit();
1682
1683 protected:
1684         /* Protected types */
1685         struct testCase
1686         {
1687                 glw::GLuint                       m_boy_offset;
1688                 Utils::Type                       m_boy_type;
1689                 glw::GLuint                       m_man_offset;
1690                 Utils::Type                       m_man_type;
1691                 Utils::Shader::STAGES m_stage;
1692         };
1693
1694         /* Protected methods */
1695         glw::GLuint gcd(glw::GLuint a, glw::GLuint b);
1696         glw::GLuint lcm(glw::GLuint a, glw::GLuint b);
1697
1698         /* Protected fields */
1699         std::vector<testCase> m_test_cases;
1700 };
1701
1702 /** Implementation of test UniformBlockMemberAlignNonPowerOf2. Description follows:
1703  *
1704  * Test verifies that align qualifier must use power of 2.
1705  *
1706  * Test following code snippet:
1707  *
1708  *     layout (std140, offset = 8) uniform Block {
1709  *         vec4 boy;
1710  *         layout (align = man_alignment) type man;
1711  *     };
1712  *
1713  * It is expected that compilation will fail whenever man_alignment is not
1714  * a power of 2.
1715  *
1716  * Test all alignment in range <0, sizeof(dmat4)>. Test all shader stages.
1717  * Test all types.
1718  **/
1719 class UniformBlockMemberAlignNonPowerOf2Test : public NegativeTestBase
1720 {
1721 public:
1722         /* Public methods */
1723         UniformBlockMemberAlignNonPowerOf2Test(deqp::Context& context);
1724
1725         UniformBlockMemberAlignNonPowerOf2Test(deqp::Context& context, const glw::GLchar* name,
1726                                                                                    const glw::GLchar* description);
1727
1728         virtual ~UniformBlockMemberAlignNonPowerOf2Test()
1729         {
1730         }
1731
1732 protected:
1733         /* Methods to be implemented by child class */
1734         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1735
1736         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1737         virtual glw::GLuint getTestCaseNumber();
1738         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1739         virtual bool isFailureExpected(glw::GLuint test_case_index);
1740         virtual bool isStageSupported(Utils::Shader::STAGES stage);
1741         virtual void testInit();
1742
1743 protected:
1744         /* Protected types */
1745         struct testCase
1746         {
1747                 glw::GLuint                       m_alignment;
1748                 Utils::Type                       m_type;
1749                 bool                              m_should_fail;
1750                 Utils::Shader::STAGES m_stage;
1751         };
1752
1753         /* Protected methods */
1754         bool isPowerOf2(glw::GLuint val);
1755
1756         /* Protected fields */
1757         std::vector<testCase> m_test_cases;
1758 };
1759
1760 /** Implementation of test UniformBlockAlignment. Description follows:
1761  *
1762  * UniformBlockAlignment
1763  *
1764  *   Test verifies that align qualifier is applied to block members as specified.
1765  *
1766  *   This test implements Texture algorithm. Test following code snippet:
1767  *
1768  *       struct Data {
1769  *           vec4  vector;
1770  *           float scalar;
1771  *       };
1772  *
1773  *       layout (std140, offset = 8, align = 64) uniform Block {
1774  *                               vec4 first;
1775  *                               Data second;
1776  *                               Data third[2];
1777  *                               vec4 fourth[3];
1778  *           layout (align = 16) vec4 fifth[2];
1779  *                               Data sixth;
1780  *       };
1781  *
1782  *   Verify that all uniforms have correct values. Additionally inspect program
1783  *   to check that all offsets are as expected.
1784  **/
1785 class UniformBlockAlignmentTest : public TextureTestBase
1786 {
1787 public:
1788         /* Public methods */
1789         UniformBlockAlignmentTest(deqp::Context& context);
1790
1791         virtual ~UniformBlockAlignmentTest()
1792         {
1793         }
1794
1795 protected:
1796         /* Protected methods */
1797         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1798                                                                          Utils::VaryingPassthrough& varying_passthrough);
1799
1800 private:
1801         std::vector<glw::GLubyte> m_data;
1802 };
1803
1804 /** Implementation of test SSBMemberOffsetAndAlign. Description follows:
1805  *
1806  * Test verifies that:
1807  *     - offset and align qualifiers are respected for shader storage block
1808  *     members,
1809  *     - align qualifier is ignored if value is too small,
1810  *     - align qualifier accepts values bigger than size of base type,
1811  *     - manual and automatic offsets and alignments can be mixed.
1812  *
1813  * Modify UniformBlockMemberOffsetAndAlign to test shader storage block instead
1814  * of uniform block.
1815  **/
1816 class SSBMemberOffsetAndAlignTest : public TextureTestBase
1817 {
1818 public:
1819         /* Public methods */
1820         SSBMemberOffsetAndAlignTest(deqp::Context& context);
1821         virtual ~SSBMemberOffsetAndAlignTest()
1822         {
1823         }
1824
1825 protected:
1826         /* Protected methods */
1827         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1828                                                                          Utils::VaryingPassthrough& varying_passthrough);
1829
1830         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1831         virtual glw::GLuint getTestCaseNumber();
1832
1833         virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1834                                                                                            Utils::Shader::STAGES stage);
1835
1836         virtual bool isDrawRelevant(glw::GLuint test_case_index);
1837
1838 private:
1839         std::vector<glw::GLubyte> m_data;
1840 };
1841
1842 /** Implementation of test SSBLayoutQualifierConflict. Description follows:
1843  *
1844  * Test verifies that offset and align can only be used on members of blocks
1845  * declared as std140 or std430.
1846  *
1847  * Modify UniformBlockMemberOffsetAndAlign to test shader storage block instead
1848  * of uniform block.
1849  *
1850  * Qualifier std430 is allowed for shader storage blocks, it should be included
1851  * in test. It is expected that std430 case will build successfully.
1852  **/
1853 class SSBLayoutQualifierConflictTest : public NegativeTestBase
1854 {
1855 public:
1856         /* Public methods */
1857         SSBLayoutQualifierConflictTest(deqp::Context& context);
1858
1859         virtual ~SSBLayoutQualifierConflictTest()
1860         {
1861         }
1862
1863 protected:
1864         /* Methods to be implemented by child class */
1865         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1866
1867         virtual std::string getTestCaseName(glw::GLuint test_case_index);
1868         virtual glw::GLuint getTestCaseNumber();
1869         virtual bool isComputeRelevant(glw::GLuint test_case_index);
1870         virtual bool isFailureExpected(glw::GLuint test_case_index);
1871         virtual void testInit();
1872
1873 private:
1874         /* Private enums */
1875         enum QUALIFIERS
1876         {
1877                 DEFAULT,
1878                 STD140,
1879                 STD430,
1880                 SHARED,
1881                 PACKED,
1882
1883                 /* */
1884                 QUALIFIERS_MAX,
1885         };
1886
1887         /* Private types */
1888         struct testCase
1889         {
1890                 QUALIFIERS                        m_qualifier;
1891                 Utils::Shader::STAGES m_stage;
1892         };
1893
1894         /* Private methods */
1895         const glw::GLchar* getQualifierName(QUALIFIERS qualifier);
1896         bool isStageSupported(Utils::Shader::STAGES stage);
1897
1898         /* Private fields */
1899         std::vector<testCase> m_test_cases;
1900 };
1901
1902 /** Implementation of test SSBMemberInvalidOffsetAlignment. Description follows:
1903  *
1904  * Test verifies that offset alignment rules are enforced.
1905  *
1906  * Modify UniformBlockMemberInvalidOffsetAlignment to test shader
1907  * storage block against MAX_SHADER_STORAGE_BLOCK_SIZE instead of
1908  * uniform block
1909  **/
1910 class SSBMemberInvalidOffsetAlignmentTest : public UniformBlockMemberInvalidOffsetAlignmentTest
1911 {
1912 public:
1913         /* Public methods */
1914         SSBMemberInvalidOffsetAlignmentTest(deqp::Context& context);
1915
1916         virtual ~SSBMemberInvalidOffsetAlignmentTest()
1917         {
1918         }
1919
1920 protected:
1921         /* Methods to be implemented by child class */
1922         virtual glw::GLint  getMaxBlockSize();
1923         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1924
1925         virtual bool isStageSupported(Utils::Shader::STAGES stage);
1926 };
1927
1928 /** Implementation of test SSBMemberOverlappingOffsets. Description follows:
1929  *
1930  * Test verifies that block members cannot overlap.
1931  *
1932  * Modify UniformBlockMemberOverlappingOffsets to test shader storage block
1933  * instead of uniform block.
1934  **/
1935 class SSBMemberOverlappingOffsetsTest : public UniformBlockMemberOverlappingOffsetsTest
1936 {
1937 public:
1938         /* Public methods */
1939         SSBMemberOverlappingOffsetsTest(deqp::Context& context);
1940         virtual ~SSBMemberOverlappingOffsetsTest()
1941         {
1942         }
1943
1944 protected:
1945         /* Methods to be implemented by child class */
1946         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1947
1948         virtual bool isStageSupported(Utils::Shader::STAGES stage);
1949 };
1950
1951 /** Implementation of test SSBMemberAlignNonPowerOf2. Description follows:
1952  *
1953  * Test verifies that align qualifier must use power of 2.
1954  *
1955  * Modify UniformBlockMemberAlignNonPowerOf2 to test shader storage block
1956  * instead of uniform block.
1957  **/
1958 class SSBMemberAlignNonPowerOf2Test : public UniformBlockMemberAlignNonPowerOf2Test
1959 {
1960 public:
1961         /* Public methods */
1962         SSBMemberAlignNonPowerOf2Test(deqp::Context& context);
1963
1964         virtual ~SSBMemberAlignNonPowerOf2Test()
1965         {
1966         }
1967
1968 protected:
1969         /* Methods to be implemented by child class */
1970         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
1971
1972         virtual bool isStageSupported(Utils::Shader::STAGES stage);
1973 };
1974
1975 /** Implementation of test SSBAlignment. Description follows:
1976  *
1977  * Test verifies that align qualifier is applied to block members as specified.
1978  *
1979  * Modify UniformBlockAlignment to test shader storage block instead
1980  * of uniform block.
1981  **/
1982 class SSBAlignmentTest : public TextureTestBase
1983 {
1984 public:
1985         /* Public methods */
1986         SSBAlignmentTest(deqp::Context& context);
1987
1988         virtual ~SSBAlignmentTest()
1989         {
1990         }
1991
1992 protected:
1993         /* Protected methods */
1994         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
1995                                                                          Utils::VaryingPassthrough& varying_passthrough);
1996
1997         virtual bool isDrawRelevant(glw::GLuint test_case_index);
1998
1999 private:
2000         std::vector<glw::GLubyte> m_data;
2001 };
2002
2003 /** Implementation of test VaryingLocations. Description follows:
2004  *
2005  * Test verifies that "varying" locations are assigned as declared in shader.
2006  *
2007  * This test implements Texture algorithm. Use separate shader objects instead
2008  * of monolithic program. Test following code snippet:
2009  *
2010  *     layout(location = 0)           in  type input_at_first_location;
2011  *     layout(location = last_input)  in  type input_at_last_location;
2012  *     layout(location = 1)           out type output_at_first_location;
2013  *     layout(location = last_output) out type output_at_last_location;
2014  *
2015  *     output_at_first_location = input_at_first_location;
2016  *     output_at_last_location  = input_at_last_location;
2017  *
2018  *     if ( (EXPECTED_VALUE == input_at_first_location) &&
2019  *          (EXPECTED_VALUE == input_at_last_location)  )
2020  *     {
2021  *         result = 1;
2022  *     }
2023  *
2024  * Additionally inspect program to check that all locations are as expected.
2025  *
2026  * Test all types. Test all shader stages.
2027  **/
2028 class VaryingLocationsTest : public TextureTestBase
2029 {
2030 public:
2031         VaryingLocationsTest(deqp::Context& context);
2032
2033         VaryingLocationsTest(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);
2034
2035         ~VaryingLocationsTest()
2036         {
2037         }
2038
2039 protected:
2040         /* Protected methods */
2041         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
2042                                                                          Utils::VaryingPassthrough& varying_passthrough);
2043
2044         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2045         virtual glw::GLuint getTestCaseNumber();
2046         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2047         virtual bool useMonolithicProgram(glw::GLuint test_case_index);
2048
2049         /* To be implemented by children */
2050         virtual void prepareShaderStage(Utils::Shader::STAGES stage, const Utils::Type& type,
2051                                                                         Utils::ProgramInterface&   program_interface,
2052                                                                         Utils::VaryingPassthrough& varying_passthrough);
2053
2054         /* Protected methods */
2055         std::string prepareGlobals(glw::GLint last_in_loc, glw::GLint last_out_loc);
2056
2057         /* Protected fields */
2058         std::vector<glw::GLubyte> m_first_data;
2059         std::vector<glw::GLubyte> m_last_data;
2060 };
2061
2062 /** Implementation of test VertexAttribLocations. Description follows:
2063  *
2064  * Test verifies that drawing operations provide vertex attributes at expected
2065  * locations.
2066  *
2067  * This test implements Texture algorithm. Use separate shader objects instead
2068  * of monolithic program. Tessellation stages are not necessary and can be
2069  * omitted. Test following code snippet:
2070  *
2071  *     layout (location = 2) in uint vertex_index;
2072  *     layout (location = 5) in uint instance_index;
2073  *
2074  *     if ( (gl_VertexID   == vertex_index)   &&
2075  *          (gl_InstanceID == instance_index) )
2076  *     {
2077  *         result = 1;
2078  *     }
2079  *
2080  * Test following Draw* operations:
2081  *     - DrawArrays,
2082  *     - DrawArraysInstanced,
2083  *     - DrawElements,
2084  *     - DrawElementsBaseVertex,
2085  *     - DrawElementsInstanced,
2086  *     - DrawElementsInstancedBaseInstance,
2087  *     - DrawElementsInstancedBaseVertex,
2088  *     - DrawElementsInstancedBaseVertexBaseInstance.
2089  *
2090  * Number of drawn instances should be equal 4. base_vertex parameter should be
2091  * set to 4. base_instance should be set to 2.
2092  *
2093  * Values provided for "vertex_index" should match index of vertex. Values
2094  * provided for "instance_index" should match index of instance
2095  * (use VertexAttribDivisor).
2096  **/
2097 class VertexAttribLocationsTest : public TextureTestBase
2098 {
2099 public:
2100         VertexAttribLocationsTest(deqp::Context& context);
2101
2102         ~VertexAttribLocationsTest()
2103         {
2104         }
2105
2106 protected:
2107         /* Protected methods */
2108         virtual void executeDrawCall(glw::GLuint test_case_index);
2109
2110         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
2111                                                                          Utils::VaryingPassthrough& varying_passthrough);
2112
2113         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2114         virtual glw::GLuint getTestCaseNumber();
2115
2116         virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
2117                                                                                            Utils::Shader::STAGES stage);
2118
2119         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2120
2121         virtual void prepareAttributes(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
2122                                                                    Utils::Buffer& buffer, Utils::VertexArray& vao);
2123
2124         virtual bool useMonolithicProgram(glw::GLuint test_case_index);
2125
2126 private:
2127         /* Private enums */
2128         enum TESTCASES
2129         {
2130                 DRAWARRAYS,
2131                 DRAWARRAYSINSTANCED,
2132                 DRAWELEMENTS,
2133                 DRAWELEMENTSBASEVERTEX,
2134                 DRAWELEMENTSINSTANCED,
2135                 DRAWELEMENTSINSTANCEDBASEINSTANCE,
2136                 DRAWELEMENTSINSTANCEDBASEVERTEX,
2137                 DRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE,
2138
2139                 /* */
2140                 TESTCASES_MAX
2141         };
2142
2143         /* Private constants */
2144         static const glw::GLuint m_base_vertex;
2145         static const glw::GLuint m_base_instance;
2146         static const glw::GLuint m_loc_vertex;
2147         static const glw::GLuint m_loc_instance;
2148         static const glw::GLuint m_n_instances;
2149 };
2150
2151 /** Implementation of test VaryingArrayLocations. Description follows:
2152  *
2153  * VaryingArrayLocations
2154  *
2155  *   Test verifies that locations of arrays of "varying" are assigned as declared
2156  *   in shader.
2157  *
2158  *   This test implements Texture algorithm. Use separate shader objects instead
2159  *   of monolithic program. Test following code snippet:
2160  *
2161  *       layout(location = 0)           in  type in_at_first_loc[FIRST_LENGTH];
2162  *       layout(location = last_input)  in  type in_at_last_loc[LAST_LENGTH];
2163  *       layout(location = 1)           out type out_at_first_loc[FIRST_LENGTH];
2164  *       layout(location = last_output) out type out_at_last_loc[LAST_LENGTH];
2165  *
2166  *       for (uint i = 0u; i < in_at_first_loc.length(); ++i)
2167  *       {
2168  *           out_at_first_loc[i] = in_at_first_loc[i];
2169  *
2170  *           if (EXPECTED_VALUE[i] != in_at_first_loc[i])
2171  *           {
2172  *               result = 0;
2173  *           }
2174  *       }
2175  *
2176  *       for (uint i = 0u; i < in_at_last_loc.length(); ++i)
2177  *       {
2178  *           out_at_last_loc[i] = in_at_last_loc[i];
2179  *
2180  *           if (EXPECTED_VALUE[i] != in_at_last_loc[i])
2181  *           {
2182  *               result = 0;
2183  *           }
2184  *       }
2185  *
2186  *   FIRST_LENGTH and LAST_LENGTH values should be selected so as not to exceed
2187  *   limits.
2188  *
2189  *   Additionally inspect program to check that all locations are as expected.
2190  *
2191  *   Test all types. Test all shader stages.
2192  **/
2193 class VaryingArrayLocationsTest : public VaryingLocationsTest
2194 {
2195 public:
2196         VaryingArrayLocationsTest(deqp::Context& context);
2197
2198         ~VaryingArrayLocationsTest()
2199         {
2200         }
2201
2202 protected:
2203         /* Protected methods */
2204         virtual void prepareShaderStage(Utils::Shader::STAGES stage, const Utils::Type& type,
2205                                                                         Utils::ProgramInterface&   program_interface,
2206                                                                         Utils::VaryingPassthrough& varying_passthrough);
2207 };
2208
2209 /** Implementation of test VaryingStructureLocations. Description follows:
2210  *
2211  * Test verifies that structures locations are as expected.
2212  *
2213  * This test implements Texture algorithm. Use separate shader objects instead
2214  * of monolithic program. Test following code snippet:
2215  *
2216  *     struct Data
2217  *     {
2218  *         type single;
2219  *         type array[ARRAY_LENGTH];
2220  *     };
2221  *
2222  *     layout (location = INPUT_LOCATION)  in  Data input[VARYING_LENGTH];
2223  *     layout (location = OUTPUT_LOCATION) out Data output[VARYING_LENGTH];
2224  *
2225  *     if ( (EXPECTED_VALUE == input[0].single)         &&
2226  *          (EXPECTED_VALUE == input[0].array[0])       &&
2227  *          (EXPECTED_VALUE == input[0].array[last])    &&
2228  *          (EXPECTED_VALUE == input[last].single)      &&
2229  *          (EXPECTED_VALUE == input[last].array[0])    &&
2230  *          (EXPECTED_VALUE == input[last].array[last]) )
2231  *     {
2232  *         result = 1;
2233  *     }
2234  *
2235  *     output[0].single         = input[0].single;
2236  *     output[0].array[0]       = input[0].array[0];
2237  *     output[0].array[last]    = input[0].array[last];
2238  *     output[last].single      = input[last].single;
2239  *     output[last].array[0]    = input[last].array[0];
2240  *     output[last].array[last] = input[last].array[last];
2241  *
2242  * Select array lengths and locations so as no limits are exceeded.
2243  **/
2244
2245 class VaryingStructureLocationsTest : public TextureTestBase
2246 {
2247 public:
2248         VaryingStructureLocationsTest(deqp::Context& context);
2249
2250         ~VaryingStructureLocationsTest()
2251         {
2252         }
2253
2254 protected:
2255         /* Protected methods */
2256         virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough,
2257                                                                            Utils::Shader::STAGES stage);
2258
2259         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
2260                                                                          Utils::VaryingPassthrough& varying_passthrough);
2261
2262         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2263         virtual glw::GLuint getTestCaseNumber();
2264         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2265         virtual bool useMonolithicProgram(glw::GLuint test_case_index);
2266
2267         /* Protected fields */
2268         std::vector<glw::GLubyte> m_single_data;
2269         std::vector<glw::GLubyte> m_array_data;
2270         std::vector<glw::GLubyte> m_data;
2271 };
2272
2273 /** Implementation of test VaryingStructureMemberLocation. Description follows:
2274  *
2275  * Test verifies that it is not allowed to declare structure member at specific
2276  * location.
2277  *
2278  * Test following code snippet:
2279  *
2280  *     struct Data
2281  *     {
2282  *         vec4 gohan;
2283  *         layout (location = LOCATION) vec4 goten;
2284  *     }
2285  *
2286  *     in Data goku;
2287  *
2288  * Select LOCATION so as not to exceed limits. Test all shader stages. Test
2289  * both in and out varyings.
2290  *
2291  * It is expected that compilation will fail.
2292  **/
2293 class VaryingStructureMemberLocationTest : public NegativeTestBase
2294 {
2295 public:
2296         VaryingStructureMemberLocationTest(deqp::Context& context);
2297
2298         ~VaryingStructureMemberLocationTest()
2299         {
2300         }
2301
2302 protected:
2303         /* Methods to be implemented by child class */
2304         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2305
2306         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2307         virtual glw::GLuint getTestCaseNumber();
2308         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2309         virtual void testInit();
2310
2311 private:
2312         /* Private types */
2313         struct testCase
2314         {
2315                 bool                              m_is_input;
2316                 Utils::Shader::STAGES m_stage;
2317         };
2318
2319         /* Private fields */
2320         std::vector<testCase> m_test_cases;
2321 };
2322
2323 /** Implementation of test VaryingBlockLocations. Description follows:
2324  *
2325  * Test verifies that "block varyings" locations are as expected.
2326  *
2327  * This test implements Texture algorithm. Use separate shader objects instead
2328  * of monolithic program. Test following code snippet:
2329  *
2330  *     layout (location = GOKU_LOCATION) in Goku
2331  *     {
2332  *                                            vec4 gohan;
2333  *         layout (location = GOTEN_LOCATION) vec4 goten;
2334  *                                            vec4 chichi;
2335  *     };
2336  *
2337  *     layout (location = VEGETA_LOCATION) out Vegeta
2338  *     {
2339  *                                          vec4 trunks;
2340  *         layout (location = BRA_LOCATION) vec4 bra;
2341  *                                          vec4 bulma;
2342  *     };
2343  *
2344  *     if ( (EXPECTED_VALUE == gohan) &&
2345  *          (EXPECTED_VALUE == goten) &&
2346  *          (EXPECTED_VALUE == chichi) )
2347  *     {
2348  *         result = 1;
2349  *     }
2350  *
2351  *     trunks = gohan;
2352  *     bra    = goten;
2353  *     bulma  = chichi;
2354  *
2355  * Select all locations so as not to cause any conflicts or exceed limits.
2356  **/
2357 class VaryingBlockLocationsTest : public TextureTestBase
2358 {
2359 public:
2360         VaryingBlockLocationsTest(deqp::Context& context);
2361         ~VaryingBlockLocationsTest()
2362         {
2363         }
2364
2365 protected:
2366         /* Protected methods */
2367         virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough,
2368                                                                            Utils::Shader::STAGES stage);
2369
2370         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
2371                                                                          Utils::VaryingPassthrough& varying_passthrough);
2372
2373         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2374         virtual bool useMonolithicProgram(glw::GLuint test_case_index);
2375
2376         /* Protected fields */
2377         std::vector<glw::GLubyte> m_third_data;
2378         std::vector<glw::GLubyte> m_fourth_data;
2379         std::vector<glw::GLubyte> m_fifth_data;
2380         std::vector<glw::GLubyte> m_data;
2381 };
2382
2383 /** Implementation of test VaryingBlockMemberLocations. Description follows:
2384  *
2385  * Test verifies that it is a compilation error to declare some of block
2386  * members with location qualifier, but not all, when there is no "block level"
2387  * location qualifier.
2388  *
2389  * Test following code snippets:
2390  *
2391  *     in Goku
2392  *     {
2393  *         vec4 gohan;
2394  *         layout (location = GOTEN_LOCATION) vec4 goten;
2395  *         vec4 chichi;
2396  *     };
2397  *
2398  * ,
2399  *
2400  *     in Goku
2401  *     {
2402  *         layout (location = GOHAN_LOCATION)  vec4 gohan;
2403  *         layout (location = GOTEN_LOCATION)  vec4 goten;
2404  *         layout (location = CHICHI_LOCATION) vec4 chichi;
2405  *     };
2406  *
2407  * Select all locations so as not to exceed any limits.
2408  *
2409  * It is expected that compilation of first snippet will fail. Compilation of
2410  * second snippet should be successful.
2411  *
2412  * Test all shader stages. Test both in and out blocks.
2413  **/
2414 class VaryingBlockMemberLocationsTest : public NegativeTestBase
2415 {
2416 public:
2417         /* Public methods */
2418         VaryingBlockMemberLocationsTest(deqp::Context& context);
2419
2420         virtual ~VaryingBlockMemberLocationsTest()
2421         {
2422         }
2423
2424 protected:
2425         /* Methods to be implemented by child class */
2426         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2427
2428         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2429         virtual glw::GLuint getTestCaseNumber();
2430         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2431         virtual bool isFailureExpected(glw::GLuint test_case_index);
2432         virtual void testInit();
2433
2434 private:
2435         /* Private types */
2436         struct testCase
2437         {
2438                 bool                              m_is_input;
2439                 bool                              m_qualify_all;
2440                 Utils::Shader::STAGES m_stage;
2441         };
2442
2443         /* Private fields */
2444         std::vector<testCase> m_test_cases;
2445 };
2446
2447 /** Implementation of test VaryingBlockAutomaticMemberLocations. Description follows:
2448  *
2449  * Test verifies that compiler will assign subsequent locations to block
2450  * members.
2451  *
2452  * Test following code snippet:
2453  *
2454  *     layout (location = 2) in DBZ
2455  *     {
2456  *         vec4 goku;                         // 2
2457  *         vec4 gohan[GOHAN_LENGTH];          // 3
2458  *         vec4 goten;                        // 3 + GOHAN_LENGTH
2459  *         layout (location = 1) vec4 chichi; // 1
2460  *         vec4 pan;                          // 2; ERROR location 2 used twice
2461  *     };
2462  *
2463  * Test all shader stages. Test both in and out blocks.
2464  *
2465  * It is expected that build process will fail.
2466  **/
2467 class VaryingBlockAutomaticMemberLocationsTest : public NegativeTestBase
2468 {
2469 public:
2470         /* Public methods */
2471         VaryingBlockAutomaticMemberLocationsTest(deqp::Context& context);
2472
2473         virtual ~VaryingBlockAutomaticMemberLocationsTest()
2474         {
2475         }
2476
2477 protected:
2478         /* Methods to be implemented by child class */
2479         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2480
2481         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2482         virtual glw::GLuint getTestCaseNumber();
2483         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2484         virtual void testInit();
2485
2486 private:
2487         /* Private types */
2488         struct testCase
2489         {
2490                 bool                              m_is_input;
2491                 Utils::Shader::STAGES m_stage;
2492         };
2493
2494         /* Private fields */
2495         std::vector<testCase> m_test_cases;
2496 };
2497
2498 /** Implementation of test VaryingLocationLimit. Description follows:
2499  *
2500  * Test verifies that "location" qualifier cannot exceed limits.
2501  *
2502  * Test following code snippet:
2503  *
2504  *     layout (location = LAST + 1) in type goku;
2505  *
2506  * LAST should be set to index of last available location.
2507  *
2508  * Test all types. Test all shader stages. Test both in and out varyings.
2509  *
2510  * It is expected that shader compilation will fail.
2511  **/
2512 class VaryingLocationLimitTest : public NegativeTestBase
2513 {
2514 public:
2515         /* Public methods */
2516         VaryingLocationLimitTest(deqp::Context& context);
2517
2518         virtual ~VaryingLocationLimitTest()
2519         {
2520         }
2521
2522 protected:
2523         /* Methods to be implemented by child class */
2524         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2525
2526         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2527         virtual glw::GLuint getTestCaseNumber();
2528         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2529         virtual void testInit();
2530
2531 private:
2532         /* Private types */
2533         struct testCase
2534         {
2535                 bool                              m_is_input;
2536                 Utils::Type                       m_type;
2537                 Utils::Shader::STAGES m_stage;
2538         };
2539
2540         /* Private fields */
2541         std::vector<testCase> m_test_cases;
2542 };
2543
2544 /** Implementation of test VaryingComponents. Description follows:
2545  *
2546  * VaryingComponents
2547  *
2548  *   Test verifies that "varying" can be assigned to specific components.
2549  *
2550  *   Modify VaryingLocations to test all possible combinations of components
2551  *   layout:
2552  *       - gvec4
2553  *       - scalar, gvec3
2554  *       - gvec3, scalar
2555  *       - gvec2, gvec2
2556  *       - gvec2, scalar, scalar
2557  *       - scalar, gvec2, scalar
2558  *       - scalar, scalar, gvec2
2559  *       - scalar, scalar, scalar, scalar.
2560  *
2561  *   Additionally inspect program to check that all locations and components are
2562  *   as expected.
2563  **/
2564 class VaryingComponentsTest : public VaryingLocationsTest
2565 {
2566 public:
2567         VaryingComponentsTest(deqp::Context& context);
2568
2569         VaryingComponentsTest(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description);
2570
2571         ~VaryingComponentsTest()
2572         {
2573         }
2574
2575 protected:
2576         /* Protected methods */
2577         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
2578                                                                          Utils::VaryingPassthrough& varying_passthrough);
2579
2580         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2581         virtual glw::GLuint getTestCaseNumber();
2582         virtual void            testInit();
2583         virtual bool useComponentQualifier(glw::GLuint test_case_index);
2584
2585         /* To be implemented by children */
2586         virtual glw::GLuint getArrayLength();
2587
2588 private:
2589         /* Private enums */
2590         enum COMPONENTS_LAYOUT
2591         {
2592                 GVEC4,
2593                 SCALAR_GVEC3,
2594                 GVEC3_SCALAR,
2595                 GVEC2_GVEC2,
2596                 GVEC2_SCALAR_SCALAR,
2597                 SCALAR_GVEC2_SCALAR,
2598                 SCALAR_SCALAR_GVEC2,
2599                 SCALAR_SCALAR_SCALAR_SCALAR,
2600         };
2601
2602         /* Private struct */
2603         struct descriptor
2604         {
2605                 void assign(glw::GLint component, const glw::GLchar* component_str, glw::GLint location,
2606                                         const glw::GLchar* location_str, glw::GLuint n_rows, const glw::GLchar* name);
2607
2608                 glw::GLint                 m_component;
2609                 const glw::GLchar* m_component_str;
2610                 glw::GLint                 m_location;
2611                 const glw::GLchar* m_location_str;
2612                 glw::GLuint                m_n_rows;
2613                 const glw::GLchar* m_name;
2614         };
2615
2616         struct testCase
2617         {
2618                 testCase(COMPONENTS_LAYOUT layout, Utils::Type::TYPES type);
2619
2620                 COMPONENTS_LAYOUT  m_layout;
2621                 Utils::Type::TYPES m_type;
2622         };
2623
2624         /* Private routines */
2625         std::string prepareGlobals(glw::GLuint last_in_location, glw::GLuint last_out_location);
2626
2627         std::string prepareName(const glw::GLchar* name, glw::GLint location, glw::GLint component,
2628                                                         Utils::Shader::STAGES stage, Utils::Variable::STORAGE storage);
2629
2630         std::string prepareQualifiers(const glw::GLchar* location, const glw::GLchar* component,
2631                                                                   const glw::GLchar* interpolation);
2632
2633         using VaryingLocationsTest::prepareShaderStage;
2634
2635         void prepareShaderStage(Utils::Shader::STAGES stage, const Utils::Type& vector_type,
2636                                                         Utils::ProgramInterface& program_interface, const testCase& test_case,
2637                                                         Utils::VaryingPassthrough& varying_passthrough);
2638
2639         Utils::Variable* prepareVarying(const Utils::Type& basic_type, const descriptor& desc,
2640                                                                         const glw::GLchar* interpolation, Utils::ShaderInterface& si,
2641                                                                         Utils::Shader::STAGES stage, Utils::Variable::STORAGE storage);
2642
2643         /* Private fields */
2644         std::vector<testCase>    m_test_cases;
2645         std::vector<glw::GLubyte> m_data;
2646 };
2647
2648 /** Implementation of test VaryingArrayComponents. Description follows:
2649  *
2650  * Test verifies that arrays of "varyings" can be assigned to specific
2651  * components.
2652  *
2653  * Modify VaryingComponents similarly to VaryingArrayLocations.
2654  **/
2655 class VaryingArrayComponentsTest : public VaryingComponentsTest
2656 {
2657 public:
2658         VaryingArrayComponentsTest(deqp::Context& context);
2659
2660         ~VaryingArrayComponentsTest()
2661         {
2662         }
2663
2664 protected:
2665         /* Protected methods */
2666         virtual glw::GLuint getArrayLength();
2667 };
2668
2669 /** Implementation of test VaryingExceedingComponents. Description follows:
2670  *
2671  * Test verifies that it is not allowed to exceed components.
2672  *
2673  * Test following code snippets:
2674  *
2675  *     layout (location = 1, component = COMPONENT) in type gohan;
2676  *
2677  * and
2678  *
2679  *     layout (location = 1, component = COMPONENT) in type gohan[LENGTH];
2680  *
2681  * Select COMPONENT so as to exceed space available at location, eg. 2 for
2682  * vec4. Select array length so as to not exceed limits of available locations.
2683  *
2684  * Test all types. Test all shader stages. Test both in and out varyings.
2685  *
2686  * It is expected that build process will fail.
2687  **/
2688 class VaryingExceedingComponentsTest : public NegativeTestBase
2689 {
2690 public:
2691         /* Public methods */
2692         VaryingExceedingComponentsTest(deqp::Context& context);
2693
2694         virtual ~VaryingExceedingComponentsTest()
2695         {
2696         }
2697
2698 protected:
2699         /* Methods to be implemented by child class */
2700         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2701
2702         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2703         virtual glw::GLuint getTestCaseNumber();
2704         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2705         virtual void testInit();
2706
2707 private:
2708         /* Private types */
2709         struct testCase
2710         {
2711                 glw::GLuint                       m_component;
2712                 bool                              m_is_input;
2713                 bool                              m_is_array;
2714                 Utils::Shader::STAGES m_stage;
2715                 Utils::Type                       m_type;
2716         };
2717
2718         /* Private fields */
2719         std::vector<testCase> m_test_cases;
2720 };
2721
2722 /** Implementation of test VaryingComponentWithoutLocation. Description follows:
2723  *
2724  * Test verifies that "component" qualifier cannot be used without "location"
2725  * qualifier.
2726  *
2727  * Test following code snippet:
2728  *
2729  *     layout (component = COMPONENT) in type goku;
2730  *
2731  * Test all types. Test all valid COMPONENT values. Test all shader stages.
2732  * Test both in and out varyings.
2733  *
2734  * It is expected that shader compilation will fail.
2735  **/
2736 class VaryingComponentWithoutLocationTest : public NegativeTestBase
2737 {
2738 public:
2739         /* Public methods */
2740         VaryingComponentWithoutLocationTest(deqp::Context& context);
2741
2742         virtual ~VaryingComponentWithoutLocationTest()
2743         {
2744         }
2745
2746 protected:
2747         /* Methods to be implemented by child class */
2748         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2749
2750         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2751         virtual glw::GLuint getTestCaseNumber();
2752         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2753         virtual void testInit();
2754
2755 private:
2756         /* Private types */
2757         struct testCase
2758         {
2759                 glw::GLuint                       m_component;
2760                 bool                              m_is_input;
2761                 Utils::Shader::STAGES m_stage;
2762                 Utils::Type                       m_type;
2763         };
2764
2765         /* Private fields */
2766         std::vector<testCase> m_test_cases;
2767 };
2768
2769 /** Implementation of test VaryingComponentOfInvalidType. Description follows:
2770  *
2771  * Test verifies that it is not allowed to declare matrix, struct, block and
2772  * array of those at specific component.
2773  *
2774  * Test following code snippets:
2775  *
2776  *     layout (location = 0, component = COMPONENT) in matrix_type varying;
2777  *
2778  * ,
2779  *
2780  *     layout (location = 0, component = COMPONENT)
2781  *         in matrix_type varying[LENGTH];
2782  *
2783  * ,
2784  *
2785  *     layout (location = 0, component = COMPONENT) in Block
2786  *     {
2787  *         type member;
2788  *     };
2789  *
2790  * ,
2791  *
2792  *     layout (location = 0, component = COMPONENT) in Block
2793  *     {
2794  *         type member;
2795  *     } block[LENGTH];
2796  *
2797  * ,
2798  *
2799  *     struct Data
2800  *     {
2801  *         type member;
2802  *     };
2803  *
2804  *     layout (location = 0, component = COMPONENT) in Data varying;
2805  *
2806  * and
2807  *
2808  *     struct Data
2809  *     {
2810  *         type member;
2811  *     };
2812  *
2813  *     layout (location = 0, component = COMPONENT) in Data varying[LENGTH];
2814  *
2815  * Test all types. Test all shader stages. Test both in and out varyings.
2816  *
2817  * It is expected that build process will fail.
2818  **/
2819 class VaryingComponentOfInvalidTypeTest : public NegativeTestBase
2820 {
2821 public:
2822         /* Public methods */
2823         VaryingComponentOfInvalidTypeTest(deqp::Context& context);
2824
2825         virtual ~VaryingComponentOfInvalidTypeTest()
2826         {
2827         }
2828
2829 protected:
2830         /* Methods to be implemented by child class */
2831         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2832
2833         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2834         virtual glw::GLuint getTestCaseNumber();
2835
2836         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2837         virtual void testInit();
2838
2839 private:
2840         /* Private enums */
2841         enum CASES
2842         {
2843                 MATRIX = 0,
2844                 BLOCK,
2845                 STRUCT,
2846
2847                 /* */
2848                 MAX_CASES
2849         };
2850
2851         /* Private types */
2852         struct testCase
2853         {
2854                 CASES                             m_case;
2855                 glw::GLuint                       m_component;
2856                 bool                              m_is_array;
2857                 bool                              m_is_input;
2858                 Utils::Shader::STAGES m_stage;
2859                 Utils::Type                       m_type;
2860         };
2861
2862         /* Private fields */
2863         std::vector<testCase> m_test_cases;
2864 };
2865
2866 /** Implementation of test InputComponentAliasing. Description follows:
2867  *
2868  * Test verifies that component aliasing cause compilation or linking error.
2869  *
2870  * Test following code snippet:
2871  *
2872  *     layout (location = 1, component = GOHAN_COMPONENT) in type gohan;
2873  *     layout (location = 1, component = GOTEN_COMPONENT) in type goten;
2874  *
2875  *     if (EXPECTED_VALUE == gohan)
2876  *     {
2877  *         result = 1;
2878  *     }
2879  *
2880  * Test all components combinations that cause aliasing. Test all types. Test
2881  * all shader stages. It is expected that build process will fail.
2882  *
2883  * Vertex shader allows component aliasing on input as long as only one of the
2884  * attributes is used in each execution path. Test vertex shader stage with two
2885  * variants:
2886  *     - first as presented above,
2887  *     - second, where "result = 1;" is replaced with "result = goten;".
2888  * In first case build process should succeed, in the second case build process
2889  * should fail.
2890  **/
2891 class InputComponentAliasingTest : public NegativeTestBase
2892 {
2893 public:
2894         /* Public methods */
2895         InputComponentAliasingTest(deqp::Context& context);
2896
2897         virtual ~InputComponentAliasingTest()
2898         {
2899         }
2900
2901 protected:
2902         /* Methods to be implemented by child class */
2903         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2904
2905         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2906         virtual glw::GLuint getTestCaseNumber();
2907
2908         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2909         virtual bool isFailureExpected(glw::GLuint test_case_index);
2910         virtual void testInit();
2911
2912 private:
2913         /* Private types */
2914         struct testCase
2915         {
2916                 glw::GLuint                       m_component_gohan;
2917                 glw::GLuint                       m_component_goten;
2918                 Utils::Shader::STAGES m_stage;
2919                 Utils::Type                       m_type;
2920         };
2921
2922         /* Private fields */
2923         std::vector<testCase> m_test_cases;
2924 };
2925
2926 /** Implementation of test OutputComponentAliasing. Description follows:
2927  *
2928  * Test verifies that component aliasing cause compilation or linking error.
2929  *
2930  * Test following code snippet:
2931  *
2932  *     layout (location = 1, component = GOHAN_COMPONENT) out type gohan;
2933  *     layout (location = 1, component = GOTEN_COMPONENT) out type goten;
2934  *
2935  *     gohan = GOHAN_VALUE;
2936  *     goten = GOTEN_VALUE;
2937  *
2938  * Test all components combinations that cause aliasing. Test all types. Test
2939  * all shader stages. It is expected that build process will fail.
2940  **/
2941 class OutputComponentAliasingTest : public NegativeTestBase
2942 {
2943 public:
2944         /* Public methods */
2945         OutputComponentAliasingTest(deqp::Context& context);
2946
2947         virtual ~OutputComponentAliasingTest()
2948         {
2949         }
2950
2951 protected:
2952         /* Methods to be implemented by child class */
2953         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
2954
2955         virtual std::string getTestCaseName(glw::GLuint test_case_index);
2956         virtual glw::GLuint getTestCaseNumber();
2957         virtual bool isComputeRelevant(glw::GLuint test_case_index);
2958         virtual void testInit();
2959
2960 private:
2961         /* Private types */
2962         struct testCase
2963         {
2964                 glw::GLuint                       m_component_gohan;
2965                 glw::GLuint                       m_component_goten;
2966                 Utils::Shader::STAGES m_stage;
2967                 Utils::Type                       m_type;
2968         };
2969
2970         /* Private fields */
2971         std::vector<testCase> m_test_cases;
2972 };
2973
2974 /** Implementation of test VaryingLocationAliasingWithMixedTypes. Description follows:
2975  *
2976  * Test verifies that it is not allowed to mix integer and float base types at
2977  * aliased location.
2978  *
2979  * Test following code snippet:
2980  *
2981  *     layout (location = 1, component = GOHAN_COMPONENT) in gohan_type gohan;
2982  *     layout (location = 1, component = GOTEN_COMPONENT) in goten_type goten;
2983  *
2984  * Test all components combinations that do not cause component aliasing. Test
2985  * all types combinations that cause float/integer conflict. Test all shader
2986  * stages. Test both in and out varyings.
2987  *
2988  * It is expected that build process will fail.
2989  **/
2990 class VaryingLocationAliasingWithMixedTypesTest : public NegativeTestBase
2991 {
2992 public:
2993         /* Public methods */
2994         VaryingLocationAliasingWithMixedTypesTest(deqp::Context& context);
2995
2996         virtual ~VaryingLocationAliasingWithMixedTypesTest()
2997         {
2998         }
2999
3000 protected:
3001         /* Methods to be implemented by child class */
3002         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3003
3004         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3005         virtual glw::GLuint getTestCaseNumber();
3006         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3007         virtual void testInit();
3008
3009 private:
3010         /* Private types */
3011         struct testCase
3012         {
3013                 glw::GLuint                       m_component_gohan;
3014                 glw::GLuint                       m_component_goten;
3015                 bool                              m_is_input;
3016                 Utils::Shader::STAGES m_stage;
3017                 Utils::Type                       m_type_gohan;
3018                 Utils::Type                       m_type_goten;
3019         };
3020
3021         /* Private routines */
3022         bool isFloatType(const Utils::Type& type);
3023
3024         /* Private fields */
3025         std::vector<testCase> m_test_cases;
3026 };
3027
3028 /** Implementation of test VaryingLocationAliasingWithMixedInterpolation. Description follows:
3029  *
3030  * Test verifies that it is not allowed to mix interpolation methods at aliased
3031  * location.
3032  *
3033  * Test following code snippet:
3034  *
3035  *     layout (location = 1, component = GOHAN_COMPONENT)
3036  *         GOHAN_INTERPOLATION in type gohan;
3037  *     layout (location = 1, component = GOTEN_COMPONENT)
3038  *         GOTEN_INTERPOLATION in type goten;
3039  *
3040  * Test all interpolation combinations that cause conflict. Select components
3041  * so as not to cause component aliasing. Test all types. Test all shader
3042  * stages. Test both in and out varyings.
3043  *
3044  * Note, that vertex shader's input and fragment shader's output cannot be
3045  * qualified with interpolation method.
3046  *
3047  * It is expected that build process will fail.
3048  **/
3049 class VaryingLocationAliasingWithMixedInterpolationTest : public NegativeTestBase
3050 {
3051 public:
3052         /* Public methods */
3053         VaryingLocationAliasingWithMixedInterpolationTest(deqp::Context& context);
3054
3055         virtual ~VaryingLocationAliasingWithMixedInterpolationTest()
3056         {
3057         }
3058
3059 protected:
3060         /* Methods to be implemented by child class */
3061         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3062
3063         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3064         virtual glw::GLuint getTestCaseNumber();
3065         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3066         virtual void testInit();
3067
3068 private:
3069         enum INTERPOLATIONS
3070         {
3071                 SMOOTH = 0,
3072                 FLAT,
3073                 NO_PERSPECTIVE,
3074
3075                 /* */
3076                 INTERPOLATION_MAX
3077         };
3078
3079         /* Private types */
3080         struct testCase
3081         {
3082                 glw::GLuint                       m_component_gohan;
3083                 glw::GLuint                       m_component_goten;
3084                 INTERPOLATIONS            m_interpolation_gohan;
3085                 INTERPOLATIONS            m_interpolation_goten;
3086                 bool                              m_is_input;
3087                 Utils::Shader::STAGES m_stage;
3088                 Utils::Type                       m_type_gohan;
3089                 Utils::Type                       m_type_goten;
3090         };
3091
3092         /* Private routines */
3093         const glw::GLchar* getInterpolationQualifier(INTERPOLATIONS interpolation);
3094         bool isFloatType(const Utils::Type& type);
3095
3096         /* Private fields */
3097         std::vector<testCase> m_test_cases;
3098 };
3099
3100 /** Implementation of test VaryingLocationAliasingWithMixedAuxiliaryStorage. Description follows:
3101  *
3102  * Test verifies that it is not allowed to mix auxiliary storage at aliased
3103  * location.
3104  *
3105  * Test following code snippet:
3106  *
3107  * layout (location = 1, component = GOHAN_COMPONENT)
3108  *     GOHAN_AUXILIARY in type gohan;
3109  * layout (location = 1, component = GOTEN_COMPONENT)
3110  *     GOTEN_AUXILIARY in type goten;
3111  *
3112  * Test all auxiliary storage combinations that cause conflict. Select
3113  * components so as not to cause component aliasing. Test all types. Test all
3114  * shader stages. Test both in and out varyings.
3115  *
3116  * It is expected that build process will fail.
3117  **/
3118 class VaryingLocationAliasingWithMixedAuxiliaryStorageTest : public NegativeTestBase
3119 {
3120 public:
3121         /* Public methods */
3122         VaryingLocationAliasingWithMixedAuxiliaryStorageTest(deqp::Context& context);
3123
3124         virtual ~VaryingLocationAliasingWithMixedAuxiliaryStorageTest()
3125         {
3126         }
3127
3128 protected:
3129         /* Methods to be implemented by child class */
3130         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3131
3132         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3133         virtual glw::GLuint getTestCaseNumber();
3134         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3135         virtual void testInit();
3136
3137 private:
3138         enum AUXILIARIES
3139         {
3140                 NONE = 0,
3141                 PATCH,
3142                 CENTROID,
3143                 SAMPLE,
3144
3145                 /* */
3146                 AUXILIARY_MAX
3147         };
3148
3149         /* Private types */
3150         struct testCase
3151         {
3152                 glw::GLuint                       m_component_gohan;
3153                 glw::GLuint                       m_component_goten;
3154                 AUXILIARIES                       m_aux_gohan;
3155                 AUXILIARIES                       m_aux_goten;
3156                 const glw::GLchar*      m_int_gohan;
3157                 const glw::GLchar*      m_int_goten;
3158                 bool                              m_is_input;
3159                 Utils::Shader::STAGES m_stage;
3160                 Utils::Type                       m_type_gohan;
3161                 Utils::Type                       m_type_goten;
3162         };
3163
3164         /* Private routines */
3165         const glw::GLchar* getAuxiliaryQualifier(AUXILIARIES aux);
3166         bool isFloatType(const Utils::Type& type);
3167
3168         /* Private fields */
3169         std::vector<testCase> m_test_cases;
3170 };
3171
3172 /** Implementation of test VertexAttribLocationAPI. Description follows:
3173  *
3174  * Test verifies that vertex attribute location API works as expected.
3175  *
3176  * This test implements Texture algorithm. Tessellation shaders are not
3177  * necessary and can be omitted. Test following code snippet in vertex shader:
3178  *
3179  *     layout (location = GOKU_LOCATION) in vec4 goku;
3180  *                                       in vec4 gohan;
3181  *                                       in vec4 goten;
3182  *                                       in vec4 chichi;
3183  *
3184  *     if ( (EXPECTED_VALUE == goku)   &&
3185  *          (EXPECTED_VALUE == gohan)  &&
3186  *          (EXPECTED_VALUE == gotan)  &&
3187  *          (EXPECTED_VALUE == chichi) )
3188  *     {
3189  *         result = 1;
3190  *     }
3191  *
3192  * After compilation, before program is linked, specify locations for goku,
3193  * and goten with glBindAttribLocation. Specify different location than the one
3194  * used in shader.
3195  *
3196  * Select all locations so as not to exceed any limits.
3197  *
3198  * Additionally inspect program to verify that:
3199  *     - goku location is as specified in shader text,
3200  *     - goten location is as specified with API.
3201  **/
3202 class VertexAttribLocationAPITest : public TextureTestBase
3203 {
3204 public:
3205         VertexAttribLocationAPITest(deqp::Context& context);
3206
3207         ~VertexAttribLocationAPITest()
3208         {
3209         }
3210
3211 protected:
3212         /* Protected methods */
3213         virtual void prepareAttribLocation(Utils::Program& program, Utils::ProgramInterface& program_interface);
3214
3215         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
3216                                                                          Utils::VaryingPassthrough& varying_passthrough);
3217
3218         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3219
3220 private:
3221         /* Private fields */
3222         std::vector<glw::GLubyte> m_goku_data;
3223         std::vector<glw::GLubyte> m_gohan_data;
3224         std::vector<glw::GLubyte> m_goten_data;
3225         std::vector<glw::GLubyte> m_chichi_data;
3226
3227         /* Private constants */
3228         static const glw::GLuint m_goten_location;
3229 };
3230 /** Implementation of test FragmentDataLocationAPI. Description follows:
3231  *
3232  * Test verifies that fragment data location API works as expected.
3233  *
3234  * This test implements Texture algorithm. Tessellation shaders are not
3235  * necessary and can be omitted. "result" is not necessary and can be omitted.
3236  * Test following code snippet in fragment shader:
3237  *
3238  *     layout (location = GOKU_LOCATION)  out vec4 goku;
3239  *                                        out vec4 gohan;
3240  *                                        out vec4 goten;
3241  *                                        out vec4 chichi;
3242  *
3243  *     goku   = EXPECTED_VALUE;
3244  *     gohan  = EXPECTED_VALUE;
3245  *     goten  = EXPECTED_VALUE;
3246  *     chichi = EXPECTED_VALUE;
3247  *
3248  * After compilation, before program is linked, specify locations for goku,
3249  * and goten with glBindFragDataLocation. Specify different location than the
3250  * one used in shader.
3251  *
3252  * Select all locations so as not to exceed any limits.
3253  *
3254  * Additionally inspect program to verify that:
3255  *     - goku location is as specified in shader text,
3256  *     - goten location is as specified with API.
3257  **/
3258 class FragmentDataLocationAPITest : public TextureTestBase
3259 {
3260 public:
3261         FragmentDataLocationAPITest(deqp::Context& context);
3262
3263         ~FragmentDataLocationAPITest()
3264         {
3265         }
3266
3267 protected:
3268         /* Protected methods */
3269         virtual bool checkResults(glw::GLuint test_case_index, Utils::Texture& color_0);
3270
3271         virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough,
3272                                                                            Utils::Shader::STAGES stage);
3273
3274         virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface,
3275                                                                          Utils::VaryingPassthrough& varying_passthrough);
3276
3277         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3278
3279         virtual void prepareFragmentDataLoc(Utils::Program& program, Utils::ProgramInterface& program_interface);
3280
3281         virtual void prepareFramebuffer(Utils::Framebuffer& framebuffer, Utils::Texture& color_0_texture);
3282
3283 private:
3284         /* Private fields */
3285         Utils::Texture m_goku;
3286         Utils::Texture m_gohan;
3287         Utils::Texture m_goten;
3288         Utils::Texture m_chichi;
3289
3290         glw::GLint m_goku_location;
3291         glw::GLint m_gohan_location;
3292         glw::GLint m_chichi_location;
3293
3294         /* Private constants */
3295         static const glw::GLuint m_goten_location;
3296 };
3297
3298 /** Implementation of test XFBInput. Description follows:
3299  *
3300  * Test verifies that using xfb_buffer, xfb_stride or xfb_offset qualifiers on
3301  * input variables will cause failure of build process.
3302  *
3303  * Test all shader stages.
3304  **/
3305 class XFBInputTest : public NegativeTestBase
3306 {
3307 public:
3308         /* Public methods */
3309         XFBInputTest(deqp::Context& context);
3310         virtual ~XFBInputTest()
3311         {
3312         }
3313
3314 protected:
3315         /* Methods to be implemented by child class */
3316         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3317
3318         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3319         virtual glw::GLuint getTestCaseNumber();
3320         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3321         virtual void testInit();
3322
3323 private:
3324         enum QUALIFIERS
3325         {
3326                 BUFFER = 0,
3327                 STRIDE,
3328                 OFFSET,
3329
3330                 /* */
3331                 QUALIFIERS_MAX
3332         };
3333
3334         /* Private types */
3335         struct testCase
3336         {
3337                 QUALIFIERS                        m_qualifier;
3338                 Utils::Shader::STAGES m_stage;
3339         };
3340
3341         /* Private fields */
3342         std::vector<testCase> m_test_cases;
3343 };
3344
3345 /** Implementation of test XFBAllStages. Description follows:
3346  *
3347  * Test verifies that only outputs from last stage processing primitives can be
3348  * captured with XFB.
3349  *
3350  * This test implements Buffer algorithm. Rasterization can be discarded.
3351  *
3352  * At each stage declare a single active output variable qualified with
3353  * xfb_buffer and xfb_offset = 0. Use separate buffers for each stage.
3354  *
3355  * Test pass if outputs from geometry shader are captured, while outputs from:
3356  * vertex and tessellation stages are ignored.
3357  **/
3358 class XFBAllStagesTest : public BufferTestBase
3359 {
3360 public:
3361         XFBAllStagesTest(deqp::Context& context);
3362
3363         ~XFBAllStagesTest()
3364         {
3365         }
3366
3367 protected:
3368         /* Protected methods */
3369         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
3370
3371         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
3372                                                            std::string& out_calculations);
3373
3374         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
3375                                                                         std::string& out_interface);
3376
3377 private:
3378         /* Constants */
3379         static const glw::GLuint m_gs_index;
3380 };
3381
3382 /** Implementation of test XFBStrideOfEmptyList. Description follows:
3383  *
3384  * Test verifies that xfb_stride directive is respected even if there are no
3385  * variables qualified with xfb_offset.
3386  *
3387  * Test implements Buffer algorithm. Rasterization can be discarded.
3388  *
3389  * Test following code snippet:
3390  *
3391  *     layout (xfb_buffer = 1, xfb_stride = 64) out;
3392  *
3393  * Moreover program should output something to xfb at index 0
3394  *
3395  * Test following cases:
3396  *     1 Provide buffers to XFB at index 0 and 1
3397  *     2 Provide buffer to XFB at index 1, index 0 should be missing
3398  *     3 Provide buffer to XFB at index 0, index 1 should be missing
3399  *
3400  * It is expected that:
3401  *     - BeginTransformFeedback operation will report GL_INVALID_OPERATION in cases
3402  *     2 and 3,
3403  *     - XFB at index 1 will not be modified in case 1.
3404  **/
3405 class XFBStrideOfEmptyListTest : public BufferTestBase
3406 {
3407 public:
3408         XFBStrideOfEmptyListTest(deqp::Context& context);
3409
3410         ~XFBStrideOfEmptyListTest()
3411         {
3412         }
3413
3414 protected:
3415         /* Protected methods */
3416         using BufferTestBase::executeDrawCall;
3417         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
3418
3419         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
3420
3421         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
3422                                                            std::string& out_calculations);
3423
3424         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
3425                                                                         std::string& out_interface);
3426
3427         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3428         virtual glw::GLuint getTestCaseNumber();
3429
3430 private:
3431         enum CASES
3432         {
3433                 VALID = 0,
3434                 FIRST_MISSING,
3435                 SECOND_MISSING,
3436         };
3437
3438         /* Private constants */
3439         static const glw::GLuint m_stride;
3440 };
3441
3442 /** Implementation of test XFBStrideOfEmptyListAndAPI. Description follows:
3443  *
3444  * Test verifies that xfb_stride qualifier is not overridden by API.
3445  *
3446  * Test implements Buffer algorithm. Rasterization can be discarded.
3447  *
3448  * Test following code snippet:
3449  *
3450  *     layout (xfb_buffer = 0, xfb_stride = 64) out;
3451  *
3452  * Moreover program should output something to xfb at index 1
3453
3454  * Use TransformFeedbackVaryings to declare a single vec4 output variable to be
3455  * captured.
3456  *
3457  * Test following cases:
3458  *     1 Provide buffers to XFB at index 0 and 1
3459  *     2 Provide buffer to XFB at index 1, index 0 should be missing
3460  *     3 Provide buffer to XFB at index 0, index 1 should be missing
3461  *
3462  * It is expected that:
3463  *     - BeginTransformFeedback operation will report GL_INVALID_OPERATION in cases
3464  *     2 and 3,
3465  *     - XFB at index 0 will not be modified in case 1.
3466  **/
3467 class XFBStrideOfEmptyListAndAPITest : public BufferTestBase
3468 {
3469 public:
3470         XFBStrideOfEmptyListAndAPITest(deqp::Context& context);
3471
3472         ~XFBStrideOfEmptyListAndAPITest()
3473         {
3474         }
3475
3476 protected:
3477         /* Protected methods */
3478         using BufferTestBase::executeDrawCall;
3479         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
3480         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
3481
3482         virtual void getCapturedVaryings(glw::GLuint test_case_index, Utils::Program::NameVector& captured_varyings, glw::GLint* xfb_components);
3483
3484         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
3485                                                            std::string& out_calculations);
3486
3487         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
3488                                                                         std::string& out_interface);
3489
3490         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3491         virtual glw::GLuint getTestCaseNumber();
3492
3493 private:
3494         enum CASES
3495         {
3496                 VALID = 0,
3497                 FIRST_MISSING,
3498                 SECOND_MISSING,
3499         };
3500
3501         /* Private constants */
3502         static const glw::GLuint m_stride;
3503 };
3504
3505 /** Implementation of test XFBTooSmallStride. Description follows:
3506  *
3507  * Test verifies that build process fails when xfb_stride qualifier sets not
3508  * enough space for all variables.
3509  *
3510  * Test following code snippets:
3511  *
3512  *     layout (xfb_buffer = 0, xfb_stride = 40) out;
3513  *
3514  *     layout (xfb_offset = 32) out vec4 goku;
3515  *
3516  *     goku = EXPECTED_VALUE.
3517  *
3518  * ,
3519  *
3520  *     layout (xfb_buffer = 0, xfb_stride = 32) out;
3521  *
3522  *     layout (xfb_offset = 16, xfb_stride = 32) out vec4 goku;
3523  *
3524  *     goku = EXPECTED_VALUE.
3525  *
3526  * ,
3527  *
3528  *     layout (xfb_buffer = 0, xfb_stride = 32) out;
3529  *
3530  *     layout (xfb_offset = 0) out Goku {
3531  *         vec4 gohan;
3532  *         vec4 goten;
3533  *         vec4 chichi;
3534  *     };
3535  *
3536  *     gohan  = EXPECTED_VALUE;
3537  *     goten  = EXPECTED_VALUE;
3538  *     chichi = EXPECTED_VALUE;
3539  *
3540  * ,
3541  *
3542  *     layout (xfb_buffer = 0, xfb_stride = 32) out;
3543  *
3544  *     layout (xfb_offset = 16) out vec4 goku[4];
3545  *
3546  *     goku[0] = EXPECTED_VALUE.
3547  *     goku[1] = EXPECTED_VALUE.
3548  *     goku[2] = EXPECTED_VALUE.
3549  *     goku[3] = EXPECTED_VALUE.
3550  *
3551  * It is expected that build process will fail.
3552  *
3553  * Test all shader stages.
3554  **/
3555 class XFBTooSmallStrideTest : public NegativeTestBase
3556 {
3557 public:
3558         /* Public methods */
3559         XFBTooSmallStrideTest(deqp::Context& context);
3560
3561         virtual ~XFBTooSmallStrideTest()
3562         {
3563         }
3564
3565 protected:
3566         /* Methods to be implemented by child class */
3567         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3568
3569         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3570         virtual glw::GLuint getTestCaseNumber();
3571         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3572         virtual void testInit();
3573
3574 private:
3575         enum CASES
3576         {
3577                 OFFSET = 0,
3578                 STRIDE,
3579                 BLOCK,
3580                 ARRAY,
3581
3582                 /* */
3583                 CASE_MAX
3584         };
3585
3586         /* Private types */
3587         struct testCase
3588         {
3589                 CASES                             m_case;
3590                 Utils::Shader::STAGES m_stage;
3591         };
3592
3593         /* Private fields */
3594         std::vector<testCase> m_test_cases;
3595 };
3596
3597 /** Implementation of test XFBVariableStride. Description follows:
3598  *
3599  * Test verifies that xfb_stride qualifier change stride of output variable.
3600  *
3601  * Test following code snippets:
3602  *
3603  *     layout (xfb_offset = 0, xfb_stride = 2 * sizeof(type)) out type goku;
3604  *
3605  * and
3606  *
3607  *     layout (xfb_offset = 0, xfb_stride = 2 * sizeof(type)) out type goku;
3608  *     layout (xfb_offset = sizeof(type))                     out type vegeta;
3609  *
3610  * It is expected that:
3611  *     - first snippet will build successfully,
3612  *     - second snippet will fail to build.
3613  *
3614  * Test all types. Test all shader stages.
3615  **/
3616 class XFBVariableStrideTest : public NegativeTestBase
3617 {
3618 public:
3619         /* Public methods */
3620         XFBVariableStrideTest(deqp::Context& context);
3621         virtual ~XFBVariableStrideTest()
3622         {
3623         }
3624
3625 protected:
3626         /* Methods to be implemented by child class */
3627         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3628
3629         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3630         virtual glw::GLuint getTestCaseNumber();
3631         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3632         virtual bool isFailureExpected(glw::GLuint test_case_index);
3633         virtual void testInit();
3634
3635 private:
3636         enum CASES
3637         {
3638                 VALID = 0,
3639                 INVALID,
3640
3641                 /* */
3642                 CASE_MAX
3643         };
3644
3645         /* Private types */
3646         struct testCase
3647         {
3648                 CASES                             m_case;
3649                 Utils::Shader::STAGES m_stage;
3650                 Utils::Type                       m_type;
3651         };
3652
3653         /* Private fields */
3654         std::vector<testCase> m_test_cases;
3655 };
3656
3657 /** Implementation of test XFBBlockStride. Description follows:
3658  *
3659  * Test verifies that xfb_stride qualifier change stride of output block.
3660  *
3661  * Test following code snippet:
3662  *
3663  *     layout (xfb_offset = 0, xfb_stride = 128) out Goku {
3664  *         vec4 gohan;
3665  *         vec4 goten;
3666  *         vec4 chichi;
3667  *     };
3668  *
3669  * Inspect program to check if Goku stride is 128 units.
3670  *
3671  * Test all shader stages.
3672  **/
3673 class XFBBlockStrideTest : public TestBase
3674 {
3675 public:
3676         /* Public methods */
3677         XFBBlockStrideTest(deqp::Context& context);
3678
3679         virtual ~XFBBlockStrideTest()
3680         {
3681         }
3682
3683 protected:
3684         /* Methods to be implemented by child class */
3685         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3686         virtual glw::GLuint getTestCaseNumber();
3687         virtual bool testCase(glw::GLuint test_case_index);
3688         virtual void testInit();
3689
3690 private:
3691         /* Private methods */
3692         std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3693
3694         bool inspectProgram(Utils::Program& program);
3695
3696         /* Private fields */
3697         std::vector<Utils::Shader::STAGES> m_test_cases;
3698 };
3699
3700 /** Implementation of test XFBBlockMemberStride. Description follows:
3701  *
3702  * Test verifies that xfb_stride qualifier change stride of output block
3703  * member.
3704  *
3705  * This test implements Buffer algorithm. Rasterization can be discarded. Test
3706  * following code snippet:
3707  *
3708  *     layout (xfb_offset = 0) out Goku {
3709  *                                  vec4 gohan;
3710  *         layout (xfb_stride = 32) vec4 goten;
3711  *                                  vec4 chichi;
3712  *     };
3713  *
3714  *     gohan  = EXPECTED_VALUE;
3715  *     goten  = EXPECTED_VALUE;
3716  *     chichi = EXPECTED_VALUE;
3717  *
3718  * Test pass if:
3719  *     - goten stride is reported as 32,
3720  *     - chichi offset is reported as 48,
3721  *     - values captured for all members match expected values,
3722  *     - part of memory reserved for goten, that is not used, is not modified.
3723  **/
3724 class XFBBlockMemberStrideTest : public BufferTestBase
3725 {
3726 public:
3727         XFBBlockMemberStrideTest(deqp::Context& context);
3728         ~XFBBlockMemberStrideTest()
3729         {
3730         }
3731
3732 protected:
3733         /* Protected methods */
3734         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
3735
3736         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
3737                                                            std::string& out_calculations);
3738
3739         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
3740                                                                         std::string& out_interface);
3741
3742         virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream);
3743 };
3744
3745 /** Implementation of test XFBDuplicatedStride. Description follows:
3746  *
3747  * Test verifies that conflicting xfb_stride qualifiers cause build process
3748  * failure.
3749  *
3750  * Test following code snippets:
3751  *
3752  *     layout (xfb_buffer = 0, xfb_stride = 64) out;
3753  *     layout (xfb_buffer = 0, xfb_stride = 64) out;
3754  *
3755  * and
3756  *
3757  *     layout (xfb_buffer = 0, xfb_stride = 64)  out;
3758  *     layout (xfb_buffer = 0, xfb_stride = 128) out;
3759  *
3760  * It is expected that:
3761  *     - first snippet will build successfully,
3762  *     - second snippet will fail to build.
3763  **/
3764 class XFBDuplicatedStrideTest : public NegativeTestBase
3765 {
3766 public:
3767         /* Public methods */
3768         XFBDuplicatedStrideTest(deqp::Context& context);
3769
3770         virtual ~XFBDuplicatedStrideTest()
3771         {
3772         }
3773
3774 protected:
3775         /* Methods to be implemented by child class */
3776         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3777
3778         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3779         virtual glw::GLuint getTestCaseNumber();
3780         virtual bool isComputeRelevant(glw::GLuint test_case_index);
3781         virtual bool isFailureExpected(glw::GLuint test_case_index);
3782         virtual void testInit();
3783
3784 private:
3785         enum CASES
3786         {
3787                 VALID = 0,
3788                 INVALID,
3789
3790                 /* */
3791                 CASE_MAX
3792         };
3793
3794         /* Private types */
3795         struct testCase
3796         {
3797                 CASES                             m_case;
3798                 Utils::Shader::STAGES m_stage;
3799         };
3800
3801         /* Private fields */
3802         std::vector<testCase> m_test_cases;
3803 };
3804
3805 /** Implementation of test XFBGetProgramResourceAPI. Description follows:
3806  *
3807  * Test verifies that GetProgramResource* API work as expected for transform
3808  * feedback.
3809  *
3810  * Test results of following queries:
3811  *     - OFFSET,
3812  *     - TRANSFORM_FEEDBACK_BUFFER_INDEX,
3813  *     - TRANSFORM_FEEDBACK_BUFFER_STRIDE,
3814  *     - TYPE.
3815  *
3816  * Test following cases:
3817  *     - captured varyings are declared with API, TransformFeedbackVaryings
3818  *     with INTERLEAVED_ATTRIBS,
3819  *     - captured varyings are declared with API, TransformFeedbackVaryings
3820  *     with SEPARATE_ATTRIBS,
3821  *     - captured varyings are declared with "xfb" qualifiers.
3822  *
3823  * Following layout should be used in cases of INTERLEAVED_ATTRIBS and "xfb"
3824  * qualifiers:
3825  *              | var 0 | var 1 | var 2 | var 3
3826  *     buffer 0 | used  | used  | empty | used
3827  *     buffer 1 | empty | used  | empty | empty
3828  *
3829  * In "xfb" qualifiers case, use following snippet:
3830  *
3831  *     layout (xfb_buffer = 1, xfb_stride = 4 * sizeof(type)) out;
3832  *
3833  * Declaration in shader should use following order:
3834  *     buffer_0_var_1
3835  *     buffer_1_var_1
3836  *     buffer_0_var_3
3837  *     buffer_0_var_0
3838  *
3839  * To make sure that captured varyings are active, they should be assigned.
3840  *
3841  * Test all types. Test all shader stages.
3842  **/
3843 class XFBGetProgramResourceAPITest : public TestBase
3844 {
3845 public:
3846         /* Public methods */
3847         XFBGetProgramResourceAPITest(deqp::Context& context);
3848
3849         virtual ~XFBGetProgramResourceAPITest()
3850         {
3851         }
3852
3853 protected:
3854         /* Methods to be implemented by child class */
3855         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3856         virtual glw::GLuint getTestCaseNumber();
3857         virtual bool testCase(glw::GLuint test_case_index);
3858         virtual void testInit();
3859         virtual void insertSkipComponents(int num_components, Utils::Program::NameVector& varyings);
3860
3861 private:
3862         /* Private enums */
3863         enum CASES
3864         {
3865                 INTERLEAVED,
3866                 SEPARATED,
3867                 XFB,
3868         };
3869
3870         /* Private types */
3871         struct test_Case
3872         {
3873                 CASES                             m_case;
3874                 Utils::Shader::STAGES m_stage;
3875                 Utils::Type                       m_type;
3876         };
3877
3878         /* Private methods */
3879         std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
3880
3881         bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program);
3882
3883         /* Private fields */
3884         std::vector<test_Case> m_test_cases;
3885 };
3886
3887 /** Implementation of test XFBOverrideQualifiersWithAPI. Description follows:
3888  *
3889  * Test verifies that API is ignored, when qualifiers are in use.
3890  *
3891  * This test follows Buffer algorithm. Rasterization can disabled. Test
3892  * following code snippet:
3893  *
3894  *     layout (xfb_offset = 2 * sizeof(type)) out type vegeta;
3895  *                                            out type trunks;
3896  *     layout (xfb_offset = 0)                out type goku;
3897  *                                            out type gohan;
3898  *
3899  *     vegeta = EXPECTED_VALUE;
3900  *     trunks = EXPECTED_VALUE;
3901  *     goku   = EXPECTED_VALUE;
3902  *     gohan  = EXPECTED_VALUE;
3903  *
3904  * Use API, TransformFeedbackVaryings, to specify trunks and gohan as outputs
3905  * to be captured.
3906  *
3907  * Test pass if:
3908  *     - correct values are captured for vegeta and goku,
3909  *     - trunks and gohan are not captured,
3910  *     - correct stride is reported.
3911  *
3912  * Test all types. Test all shader stages.
3913  **/
3914 class XFBOverrideQualifiersWithAPITest : public BufferTestBase
3915 {
3916 public:
3917         XFBOverrideQualifiersWithAPITest(deqp::Context& context);
3918
3919         ~XFBOverrideQualifiersWithAPITest()
3920         {
3921         }
3922
3923 protected:
3924         /* Protected methods */
3925         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
3926
3927         virtual void getCapturedVaryings(glw::GLuint test_case_index, Utils::Program::NameVector& captured_varyings, glw::GLint* xfb_components);
3928
3929         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
3930                                                            std::string& out_calculations);
3931
3932         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
3933                                                                         std::string& out_interface);
3934
3935         virtual std::string getTestCaseName(glw::GLuint test_case_index);
3936         virtual glw::GLuint getTestCaseNumber();
3937
3938         virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream);
3939 };
3940
3941 /** Implementation of test XFBVertexStreams. Description follows:
3942  *
3943  * Test verifies that "xfb" qualifiers work as expected with multiple output
3944  * streams.
3945  *
3946  * Test implements Buffer algorithm. Rasterization can be discarded.
3947  *
3948  * Test following code snippet:
3949  *
3950  *     layout (xfb_buffer = 1, xfb_stride = 64) out;
3951  *     layout (xfb_buffer = 2, xfb_stride = 64) out;
3952  *     layout (xfb_buffer = 3, xfb_stride = 64) out;
3953  *
3954  *     layout (stream = 0, xfb_buffer = 1, xfb_offset = 48) out vec4 goku;
3955  *     layout (stream = 0, xfb_buffer = 1, xfb_offset = 32) out vec4 gohan;
3956  *     layout (stream = 0, xfb_buffer = 1, xfb_offset = 16) out vec4 goten;
3957  *     layout (stream = 1, xfb_buffer = 3, xfb_offset = 48) out vec4 picolo;
3958  *     layout (stream = 1, xfb_buffer = 3, xfb_offset = 32) out vec4 vegeta;
3959  *     layout (stream = 2, xfb_buffer = 2, xfb_offset = 32) out vec4 bulma;
3960  *
3961  *     goku   = EXPECTED_VALUE;
3962  *     gohan  = EXPECTED_VALUE;
3963  *     goten  = EXPECTED_VALUE;
3964  *     picolo = EXPECTED_VALUE;
3965  *     vegeta = EXPECTED_VALUE;
3966  *     bulma  = EXPECTED_VALUE;
3967  *
3968  * Test pass if all captured outputs have expected values.
3969  **/
3970 class XFBVertexStreamsTest : public BufferTestBase
3971 {
3972 public:
3973         XFBVertexStreamsTest(deqp::Context& context);
3974
3975         ~XFBVertexStreamsTest()
3976         {
3977         }
3978
3979 protected:
3980         /* Protected methods */
3981         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
3982
3983         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
3984                                                            std::string& out_calculations);
3985
3986         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
3987                                                                         std::string& out_interface);
3988 };
3989
3990 /** Implementation of test XFBMultipleVertexStreams. Description follows:
3991  *
3992  * Test verifies that outputs from single stream must be captured with single
3993  * xfb binding.
3994  *
3995  * Test following code snippet:
3996  *
3997  *     layout (xfb_buffer = 1, xfb_stride = 64) out;
3998  *     layout (xfb_buffer = 3, xfb_stride = 64) out;
3999  *
4000  *     layout (stream = 0, xfb_buffer = 1, xfb_offset = 48) out vec4 goku;
4001  *     layout (stream = 1, xfb_buffer = 1, xfb_offset = 32) out vec4 gohan;
4002  *     layout (stream = 2, xfb_buffer = 1, xfb_offset = 16) out vec4 goten;
4003  *
4004  * It is expected that linking of program will fail.
4005  **/
4006 class XFBMultipleVertexStreamsTest : public NegativeTestBase
4007 {
4008 public:
4009         /* Public methods */
4010         XFBMultipleVertexStreamsTest(deqp::Context& context);
4011
4012         virtual ~XFBMultipleVertexStreamsTest()
4013         {
4014         }
4015
4016 protected:
4017         /* Methods to be implemented by child class */
4018         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4019
4020         virtual bool isComputeRelevant(glw::GLuint test_case_index);
4021 };
4022
4023 /** Implementation of test XFBExceedBufferLimit. Description follows:
4024  *
4025  * Test verifies that MAX_TRANSFORM_FEEDBACK_BUFFERS limit is respected.
4026  *
4027  * Test following code snippets:
4028  *
4029  *     layout (xfb_buffer = MAX_TRANSFORM_FEEDBACK_BUFFERS) out;
4030  *
4031  * ,
4032  *
4033  *     layout (xfb_buffer = MAX_TRANSFORM_FEEDBACK_BUFFERS) out vec4 output;
4034  *
4035  * and
4036  *
4037  *     layout (xfb_buffer = MAX_TRANSFORM_FEEDBACK_BUFFERS) out Block {
4038  *         vec4 member;
4039  *     };
4040  *
4041  * It is expected that build process will fail.
4042  *
4043  * Test all shader stages.
4044  **/
4045 class XFBExceedBufferLimitTest : public NegativeTestBase
4046 {
4047 public:
4048         /* Public methods */
4049         XFBExceedBufferLimitTest(deqp::Context& context);
4050         virtual ~XFBExceedBufferLimitTest()
4051         {
4052         }
4053
4054 protected:
4055         /* Methods to be implemented by child class */
4056         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4057
4058         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4059         virtual glw::GLuint getTestCaseNumber();
4060         virtual bool isComputeRelevant(glw::GLuint test_case_index);
4061         virtual void testInit();
4062
4063 private:
4064         enum CASES
4065         {
4066                 BLOCK = 0,
4067                 GLOBAL,
4068                 VECTOR,
4069
4070                 /* */
4071                 CASE_MAX
4072         };
4073
4074         /* Private types */
4075         struct testCase
4076         {
4077                 CASES                             m_case;
4078                 Utils::Shader::STAGES m_stage;
4079         };
4080
4081         /* Private fields */
4082         std::vector<testCase> m_test_cases;
4083 };
4084
4085 /** Implementation of test XFBExceedOffsetLimit. Description follows:
4086  *
4087  * Test verifies that MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS limit is
4088  * respected.
4089  *
4090  * Test following code snippets:
4091  *
4092  *     layout (xfb_buffer = 0, xfb_stride = MAX_SIZE + 16) out;
4093  *
4094  * ,
4095  *
4096  *     layout (xfb_buffer = 0, xfb_offset = MAX_SIZE) out vec4 output;
4097  *
4098  * and
4099  *
4100  *     layout (xfb_buffer = 0, xfb_offset = MAX_SIZE) out Block
4101  *     {
4102  *         vec4 member;
4103  *     };
4104  *
4105  * where MAX_SIZE is the maximum supported size of transform feedback buffer,
4106  * which should be equal to:
4107  *
4108  *     MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS * sizeof(float)
4109  *
4110  * It is expected that build process will fail.
4111  *
4112  * Test all shader stages.
4113  **/
4114 class XFBExceedOffsetLimitTest : public NegativeTestBase
4115 {
4116 public:
4117         /* Public methods */
4118         XFBExceedOffsetLimitTest(deqp::Context& context);
4119         virtual ~XFBExceedOffsetLimitTest()
4120         {
4121         }
4122
4123 protected:
4124         /* Methods to be implemented by child class */
4125         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4126
4127         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4128         virtual glw::GLuint getTestCaseNumber();
4129         virtual bool isComputeRelevant(glw::GLuint test_case_index);
4130         virtual void testInit();
4131
4132 private:
4133         enum CASES
4134         {
4135                 BLOCK = 0,
4136                 GLOBAL,
4137                 VECTOR,
4138
4139                 /* */
4140                 CASE_MAX
4141         };
4142
4143         /* Private types */
4144         struct testCase
4145         {
4146                 CASES                             m_case;
4147                 Utils::Shader::STAGES m_stage;
4148         };
4149
4150         /* Private fields */
4151         std::vector<testCase> m_test_cases;
4152 };
4153
4154 /** Implementation of test XFBGlobalBuffer. Description follows:
4155  *
4156  * Test verifies that global setting of xfb_buffer qualifier work as expected.
4157  *
4158  * This test implements Buffer algorithm. Rasterization can be discarded. Test
4159  * following code snippet:
4160  *
4161  *     layout (xfb_buffer = 3) out;
4162  *
4163  *     layout (                xfb_offset = 2 * sizeof(type)) out type chichi;
4164  *     layout (xfb_buffer = 1, xfb_offset = 0)                out type bulma;
4165  *     layout (xfb_buffer = 1, xfb_offset = sizeof(type))     out Vegeta {
4166  *         type trunks;
4167  *         type bra;
4168  *     };
4169  *     layout (                xfb_offset = 0)                out Goku {
4170  *         type gohan;
4171  *         type goten;
4172  *     };
4173  *
4174  *     chichi = EXPECTED_VALUE;
4175  *     bulma  = EXPECTED_VALUE;
4176  *     trunks = EXPECTED_VALUE;
4177  *     bra    = EXPECTED_VALUE;
4178  *     gohan  = EXPECTED_VALUE;
4179  *     goten  = EXPECTED_VALUE;
4180  *
4181  * Test pass if all captured outputs have expected values.
4182  *
4183  * Test all shader stages. Test all types.
4184  **/
4185 class XFBGlobalBufferTest : public BufferTestBase
4186 {
4187 public:
4188         XFBGlobalBufferTest(deqp::Context& context);
4189
4190         ~XFBGlobalBufferTest()
4191         {
4192         }
4193
4194 protected:
4195         /* Protected methods */
4196         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
4197
4198         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4199
4200         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4201         virtual glw::GLuint getTestCaseNumber();
4202         virtual void            testInit();
4203
4204 private:
4205         /* Private types */
4206         struct _testCase
4207         {
4208                 Utils::Shader::STAGES m_stage;
4209                 Utils::Type                       m_type;
4210         };
4211
4212         /* Private fields */
4213         std::vector<_testCase> m_test_cases;
4214 };
4215
4216 /** Implementation of test XFBStride. Description follows:
4217  *
4218  * Test verifies that expected stride values are used.
4219  *
4220  * Test following code snippet:
4221  *
4222  *     layout (xfb_offset = 0) out type output;
4223  *
4224  *     output = EXPECTED_VALUE;
4225  *
4226  * Test all types. Test all shader stages.
4227  **/
4228 class XFBStrideTest : public BufferTestBase
4229 {
4230 public:
4231         XFBStrideTest(deqp::Context& context);
4232         ~XFBStrideTest()
4233         {
4234         }
4235
4236 protected:
4237         /* Protected methods */
4238         using BufferTestBase::executeDrawCall;
4239
4240         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
4241         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
4242
4243         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
4244                                                            std::string& out_calculations);
4245
4246         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
4247                                                                         std::string& out_interface);
4248
4249         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4250
4251         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4252         virtual glw::GLuint getTestCaseNumber();
4253         virtual void            testInit();
4254
4255 private:
4256         /* Private types */
4257         struct testCase
4258         {
4259                 Utils::Shader::STAGES m_stage;
4260                 Utils::Type                       m_type;
4261         };
4262
4263         /* Private fields */
4264         std::vector<testCase> m_test_cases;
4265 };
4266
4267 /** Implementation of test XFBBlockMemberBuffer. Description follows:
4268  *
4269  * Test verifies that member of block have to use same buffer as block.
4270  *
4271  * Test following code snippet:
4272  *
4273  *     layout (xfb_offset = 0) out Goku
4274  *     {
4275  *                                 vec4 gohan;
4276  *         layout (xfb_buffer = 1) vec4 goten;
4277  *     };
4278  *
4279  * It is expected that compilation will fail.
4280  *
4281  * Test all shader stages.
4282  **/
4283 class XFBBlockMemberBufferTest : public NegativeTestBase
4284 {
4285 public:
4286         /* Public methods */
4287         XFBBlockMemberBufferTest(deqp::Context& context);
4288
4289         virtual ~XFBBlockMemberBufferTest()
4290         {
4291         }
4292
4293 protected:
4294         /* Methods to be implemented by child class */
4295         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4296
4297         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4298         virtual glw::GLuint getTestCaseNumber();
4299         virtual bool isComputeRelevant(glw::GLuint test_case_index);
4300         virtual void testInit();
4301
4302 private:
4303         /* Private types */
4304         struct testCase
4305         {
4306                 Utils::Shader::STAGES m_stage;
4307         };
4308
4309         /* Private fields */
4310         std::vector<testCase> m_test_cases;
4311 };
4312
4313 /** Implementation of test XFBOutputOverlapping. Description follows:
4314  *
4315  * Test verifies that overlapped outputs are reported as errors by compiler.
4316  *
4317  * Test following code snippet:
4318  *
4319  *     layout (xfb_offset = sizeof(type))       out type gohan;
4320  *     layout (xfb_offset = 1.5 * sizeof(type)) out type goten;
4321  *
4322  *     gohan = EXPECTED_VALUE;
4323  *     goten = EXPECTED_VALUE;
4324  *
4325  * It is expected that compilation will fail.
4326  *
4327  * Test all shader stages. Test all types.
4328  **/
4329 class XFBOutputOverlappingTest : public NegativeTestBase
4330 {
4331 public:
4332         /* Public methods */
4333         XFBOutputOverlappingTest(deqp::Context& context);
4334
4335         virtual ~XFBOutputOverlappingTest()
4336         {
4337         }
4338
4339 protected:
4340         /* Methods to be implemented by child class */
4341         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4342
4343         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4344         virtual glw::GLuint getTestCaseNumber();
4345         virtual bool isComputeRelevant(glw::GLuint test_case_index);
4346         virtual void testInit();
4347
4348 private:
4349         /* Private types */
4350         struct testCase
4351         {
4352                 glw::GLuint                       m_offset_gohan;
4353                 glw::GLuint                       m_offset_goten;
4354                 Utils::Shader::STAGES m_stage;
4355                 Utils::Type                       m_type;
4356         };
4357
4358         /* Private fields */
4359         std::vector<testCase> m_test_cases;
4360 };
4361
4362 /** Implementation of test XFBInvalidOffsetAlignment. Description follows:
4363  *
4364  * Test verifies that invalidly aligned outputs cause a failure to build
4365  * process.
4366  *
4367  * Test following code snippet:
4368  *
4369  *     layout (xfb_offset = OFFSET) out type goku;
4370  *
4371  *     goku = EXPECTED_VALUE;
4372  *
4373  * Select OFFSET values so as to cause invalid alignment. Inspect program to
4374  * verify offset of goku.
4375  *
4376  * Test all shader stages. Test all types. Test all offsets in range:
4377  * (sizeof(type), 2 * sizeof(type)).
4378  **/
4379 class XFBInvalidOffsetAlignmentTest : public NegativeTestBase
4380 {
4381 public:
4382         /* Public methods */
4383         XFBInvalidOffsetAlignmentTest(deqp::Context& context);
4384
4385         virtual ~XFBInvalidOffsetAlignmentTest()
4386         {
4387         }
4388
4389 protected:
4390         /* Methods to be implemented by child class */
4391         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4392
4393         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4394         virtual glw::GLuint getTestCaseNumber();
4395         virtual bool isComputeRelevant(glw::GLuint test_case_index);
4396         virtual void testInit();
4397
4398 private:
4399         /* Private types */
4400         struct testCase
4401         {
4402                 glw::GLuint                       m_offset;
4403                 Utils::Shader::STAGES m_stage;
4404                 Utils::Type                       m_type;
4405         };
4406
4407         /* Private fields */
4408         std::vector<testCase> m_test_cases;
4409 };
4410
4411 /** Implementation of test XFBCaptureInactiveOutputVariable. Description follows:
4412  *
4413  * Test verifies behaviour of inactive outputs.
4414  *
4415  * This test implements Buffer algorithm. Rasterization can be disabled. Draw
4416  * two vertices instead of one. Test following code snippet:
4417  *
4418  *     layout (xfb_offset = 16) out vec4 goku;
4419  *     layout (xfb_offset = 32) out vec4 gohan;
4420  *     layout (xfb_offset = 0)  out vec4 goten;
4421  *
4422  *     gohan = EXPECTED_VALUE;
4423  *     goten = EXPECTED_VALUE;
4424  *
4425  * Test pass if:
4426  *     - values captured for goten and gohan are as expected,
4427  *     - goku value is undefined
4428  *     - stride is 3 * sizeof(vec4) - 48
4429  *
4430  * Test all shader stages.
4431  **/
4432 class XFBCaptureInactiveOutputVariableTest : public BufferTestBase
4433 {
4434 public:
4435         XFBCaptureInactiveOutputVariableTest(deqp::Context& context);
4436         ~XFBCaptureInactiveOutputVariableTest()
4437         {
4438         }
4439
4440 protected:
4441         /* Protected methods */
4442         using BufferTestBase::executeDrawCall;
4443         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
4444         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
4445
4446         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
4447                                                            std::string& out_calculations);
4448
4449         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
4450                                                                         std::string& out_interface);
4451
4452         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4453
4454         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4455         virtual glw::GLuint getTestCaseNumber();
4456
4457         virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream);
4458
4459         virtual bool verifyBuffers(bufferCollection& buffers);
4460
4461 private:
4462         enum test_cases
4463         {
4464                 TEST_VS = 0,
4465                 TEST_TES,
4466                 TEST_GS,
4467
4468                 /* */
4469                 TEST_MAX
4470         };
4471 };
4472
4473 /** Implementation of test XFBCaptureInactiveOutputComponent. Description follows:
4474  *
4475  * Test verifies behaviour of inactive component.
4476  *
4477  * This test implements Buffer algorithm. Rasterization can be disabled. Draw
4478  * two vertices instead of one. Test following code snippet:
4479  *
4480  *     layout (xfb_offset = 32)  out vec4 goku;
4481  *     layout (xfb_offset = 0)   out vec4 gohan;
4482  *     layout (xfb_offset = 16)  out vec4 goten;
4483  *     layout (xfb_offset = 48)  out vec4 chichi;
4484  *     layout (xfb_offset = 112) out vec4 vegeta;
4485  *     layout (xfb_offset = 96)  out vec4 trunks;
4486  *     layout (xfb_offset = 80)  out vec4 bra;
4487  *     layout (xfb_offset = 64)  out vec4 bulma;
4488  *
4489  *     goku.x   = EXPECTED_VALUE;
4490  *     goku.z   = EXPECTED_VALUE;
4491  *     gohan.y  = EXPECTED_VALUE;
4492  *     gohan.w  = EXPECTED_VALUE;
4493  *     goten.x  = EXPECTED_VALUE;
4494  *     goten.y  = EXPECTED_VALUE;
4495  *     chichi.z = EXPECTED_VALUE;
4496  *     chichi.w = EXPECTED_VALUE;
4497  *     vegeta.x = EXPECTED_VALUE;
4498  *     trunks.y = EXPECTED_VALUE;
4499  *     bra.z    = EXPECTED_VALUE;
4500  *     bulma.w  = EXPECTED_VALUE;
4501  *
4502  * Test pass when captured values of all assigned components match expected
4503  * values, while not assigned ones are undefined.
4504  *
4505  * Test all shader stages.
4506  **/
4507 class XFBCaptureInactiveOutputComponentTest : public BufferTestBase
4508 {
4509 public:
4510         XFBCaptureInactiveOutputComponentTest(deqp::Context& context);
4511         ~XFBCaptureInactiveOutputComponentTest()
4512         {
4513         }
4514
4515 protected:
4516         /* Protected methods */
4517         using BufferTestBase::executeDrawCall;
4518         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
4519
4520         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
4521
4522         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
4523                                                            std::string& out_calculations);
4524
4525         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
4526                                                                         std::string& out_interface);
4527
4528         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4529
4530         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4531         virtual glw::GLuint getTestCaseNumber();
4532         virtual bool verifyBuffers(bufferCollection& buffers);
4533
4534 private:
4535         enum test_cases
4536         {
4537                 TEST_VS = 0,
4538                 TEST_TES,
4539                 TEST_GS,
4540
4541                 /* */
4542                 TEST_MAX
4543         };
4544 };
4545
4546 /** Implementation of test XFBCaptureInactiveOutputBlockMember. Description follows:
4547  *
4548  * Test verifies behaviour of inactive block member.
4549  *
4550  * This test implements Buffer algorithm. Rasterization can be disabled. Draw
4551  * two vertices instead of one. Test following code snippet:
4552  *
4553  *     layout (xfb_offset = 16)  out Goku {
4554  *         vec4 gohan;
4555  *         vec4 goten;
4556  *         vec4 chichi;
4557  *     };
4558  *
4559  *     gohan  = EXPECTED_VALUE;
4560  *     chichi = EXPECTED_VALUE;
4561  *
4562  * Test pass when captured values of gohan and chichi match expected values.
4563  * It is expected that goten will receive undefined value.
4564  *
4565  * Test all shader stages.
4566  **/
4567 class XFBCaptureInactiveOutputBlockMemberTest : public BufferTestBase
4568 {
4569 public:
4570         XFBCaptureInactiveOutputBlockMemberTest(deqp::Context& context);
4571
4572         ~XFBCaptureInactiveOutputBlockMemberTest()
4573         {
4574         }
4575
4576 protected:
4577         /* Protected methods */
4578         using BufferTestBase::executeDrawCall;
4579         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
4580         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
4581
4582         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
4583                                                            std::string& out_calculations);
4584
4585         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
4586                                                                         std::string& out_interface);
4587
4588         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4589
4590         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4591         virtual glw::GLuint getTestCaseNumber();
4592         virtual bool verifyBuffers(bufferCollection& buffers);
4593
4594 private:
4595         enum test_cases
4596         {
4597                 TEST_VS = 0,
4598                 TEST_TES,
4599                 TEST_GS,
4600
4601                 /* */
4602                 TEST_MAX
4603         };
4604 };
4605
4606 /** Implementation of test XFBCaptureStruct. Description follows:
4607  *
4608  * Test verifies that structures are captured as expected.
4609  *
4610  * This test implements Buffer algorithm. Rasterization can be disabled. Draw
4611  * two vertices instead of one. Test following code snippet:
4612  *
4613  *     struct Goku {
4614  *         vec4 gohan;
4615  *         vec4 goten;
4616  *         vec4 chichi;
4617  *     };
4618  *
4619  *     layout (xfb_offset = 16) out Goku goku;
4620  *
4621  *     goku.gohan  = EXPECTED_VALUE;
4622  *     goku.chichi = EXPECTED_VALUE;
4623  *
4624  * Test pass when captured values of gohan and chichi match expected values.
4625  * It is expected that goten will receive undefined value.
4626  *
4627  * Test all shader stages.
4628  **/
4629 class XFBCaptureStructTest : public BufferTestBase
4630 {
4631 public:
4632         XFBCaptureStructTest(deqp::Context& context);
4633
4634         ~XFBCaptureStructTest()
4635         {
4636         }
4637
4638 protected:
4639         /* Protected methods */
4640         using BufferTestBase::executeDrawCall;
4641         virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index);
4642
4643         virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors);
4644
4645         virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments,
4646                                                            std::string& out_calculations);
4647
4648         virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage,
4649                                                                         std::string& out_interface);
4650
4651         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4652
4653         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4654         virtual glw::GLuint getTestCaseNumber();
4655         virtual bool verifyBuffers(bufferCollection& buffers);
4656
4657 private:
4658         enum test_cases
4659         {
4660                 TEST_VS = 0,
4661                 TEST_TES,
4662                 TEST_GS,
4663
4664                 /* */
4665                 TEST_MAX
4666         };
4667 };
4668
4669 /** Implementation of test XFBCaptureUnsizedArray. Description follows:
4670  *
4671  * Test verifies this is not allowed to qualify unsized array with "xfb".
4672  *
4673  * Test following code snippet:
4674  *
4675  *     layout (xfb_offset = 0) out vec4 goku[];
4676  *
4677  *     goku[0] = EXPECTED_VALUE;
4678  *
4679  * It is expected that compilation will fail.
4680  *
4681  * Test all shader stages.
4682  **/
4683 class XFBCaptureUnsizedArrayTest : public NegativeTestBase
4684 {
4685 public:
4686         /* Public methods */
4687         XFBCaptureUnsizedArrayTest(deqp::Context& context);
4688         virtual ~XFBCaptureUnsizedArrayTest()
4689         {
4690         }
4691
4692 protected:
4693         /* Methods to be implemented by child class */
4694         virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage);
4695
4696         virtual std::string getTestCaseName(glw::GLuint test_case_index);
4697         virtual glw::GLuint getTestCaseNumber();
4698         virtual bool isComputeRelevant(glw::GLuint test_case_index);
4699         virtual void testInit();
4700
4701 private:
4702         /* Private types */
4703         struct testCase
4704         {
4705                 Utils::Shader::STAGES m_stage;
4706         };
4707
4708         /* Private fields */
4709         std::vector<testCase> m_test_cases;
4710 };
4711
4712 } /* EnhancedLayouts namespace */
4713
4714 /** Group class for Shader Language 420Pack conformance tests */
4715 class EnhancedLayoutsTests : public deqp::TestCaseGroup
4716 {
4717 public:
4718         /* Public methods */
4719         EnhancedLayoutsTests(deqp::Context& context);
4720
4721         virtual ~EnhancedLayoutsTests(void)
4722         {
4723         }
4724
4725         virtual void init(void);
4726
4727 private:
4728         /* Private methods */
4729         EnhancedLayoutsTests(const EnhancedLayoutsTests& other);
4730         EnhancedLayoutsTests& operator=(const EnhancedLayoutsTests& other);
4731 };
4732
4733 } // gl4cts
4734
4735 #endif // _GL4CENHANCEDLAYOUTSTESTS_HPP