1 #ifndef _GL3CCOMMONBUGSTESTS_HPP 2 #define _GL3CCOMMONBUGSTESTS_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 */ /*! 28 * \file gl3cCommonBugsTests.hpp 29 * \brief Tiny conformance tests which verify various pieces of functionality which have 30 * either been found to be broken on at least one publically available driver, 31 * or whose behavior was found to differ across vendors. 32 */ /*-------------------------------------------------------------------*/ 33 34 #ifndef _GLCTESTCASE_HPP 35 #include "glcTestCase.hpp" 36 #endif 37 #ifndef _GLWDEFS_HPP 38 #include "glwDefs.hpp" 39 #endif 40 #ifndef _TCUDEFS_HPP 41 #include "tcuDefs.hpp" 42 #endif 43 44 namespace gl3cts 45 { 46 /* Conformance test which verifies that glGetProgramiv() accepts the GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 47 * pname and returns meaningful values. */ 48 class GetProgramivActiveUniformBlockMaxNameLengthTest : public deqp::TestCase 49 { 50 public: 51 /* Public methods */ 52 GetProgramivActiveUniformBlockMaxNameLengthTest(deqp::Context &context); 53 54 void deinit(); 55 void init(); 56 tcu::TestNode::IterateResult iterate(); 57 58 private: 59 /* Private methods */ 60 bool initTest(); 61 62 /* Private members */ 63 glw::GLuint m_fs_id; 64 glw::GLuint m_po_id; 65 glw::GLuint m_vs_id; 66 }; 67 68 /** Conformance test which verifies that input variables used in the cases described below 69 * cannot be set to any value: 70 * 71 * - input variable defined in a fragment shader. 72 * - input variable, wrapped in an input block, defined in a fragment shader. 73 * - input variable defined in a geometry shader. 74 * - input variable, wrapped in an input block, defined in a geometry shader. 75 * - input variable defined in a tessellation control shader. 76 * - input variable, wrapped in an input block, defined in a tessellation control shader. 77 * - input patch variable. defined in a tessellation evaluation shader. 78 * - input variable defined in a tessellation evaluation shader. 79 * - input variable, wrapped in an input block, defined in a tessellation evaluation shader. 80 * - input variable defined in a vertex shader. 81 * 82 * Furthermore, the test also verifies that an input variable cannot be passed as an inout 83 * or out function argument in any of the five shader stages. 84 * */ 85 class InputVariablesCannotBeModifiedTest : public deqp::TestCase 86 { 87 public: 88 /* Public methods */ 89 InputVariablesCannotBeModifiedTest(deqp::Context &context); 90 91 void deinit(); 92 void init(); 93 tcu::TestNode::IterateResult iterate(); 94 95 private: 96 /* Private type declarations */ 97 typedef enum 98 { 99 SHADER_STAGE_FRAGMENT, 100 SHADER_STAGE_GEOMETRY, 101 SHADER_STAGE_TESSELLATION_CONTROL, 102 SHADER_STAGE_TESSELLATION_EVALUATION, 103 SHADER_STAGE_VERTEX 104 } _shader_stage; 105 106 typedef enum 107 { 108 TEST_ITERATION_FIRST, 109 110 TEST_ITERATION_INPUT_FS_VARIABLE = TEST_ITERATION_FIRST, 111 TEST_ITERATION_INPUT_FS_VARIABLE_IN_INPUT_BLOCK, 112 TEST_ITERATION_INPUT_FS_VARIABLE_PASSED_TO_INOUT_FUNCTION_PARAMETER, 113 TEST_ITERATION_INPUT_FS_VARIABLE_PASSED_TO_OUT_FUNCTION_PARAMETER, 114 TEST_ITERATION_INPUT_GS_VARIABLE, 115 TEST_ITERATION_INPUT_GS_VARIABLE_IN_INPUT_BLOCK, 116 TEST_ITERATION_INPUT_GS_VARIABLE_PASSED_TO_INOUT_FUNCTION_PARAMETER, 117 TEST_ITERATION_INPUT_GS_VARIABLE_PASSED_TO_OUT_FUNCTION_PARAMETER, 118 TEST_ITERATION_INPUT_TC_VARIABLE, 119 TEST_ITERATION_INPUT_TC_VARIABLE_IN_INPUT_BLOCK, 120 TEST_ITERATION_INPUT_TC_VARIABLE_PASSED_TO_INOUT_FUNCTION_PARAMETER, 121 TEST_ITERATION_INPUT_TC_VARIABLE_PASSED_TO_OUT_FUNCTION_PARAMETER, 122 TEST_ITERATION_INPUT_TE_PATCH_VARIABLE, 123 TEST_ITERATION_INPUT_TE_VARIABLE, 124 TEST_ITERATION_INPUT_TE_VARIABLE_IN_INPUT_BLOCK, 125 TEST_ITERATION_INPUT_TE_VARIABLE_PASSED_TO_INOUT_FUNCTION_PARAMETER, 126 TEST_ITERATION_INPUT_TE_VARIABLE_PASSED_TO_OUT_FUNCTION_PARAMETER, 127 TEST_ITERATION_INPUT_VS_VARIABLE, 128 TEST_ITERATION_INPUT_VS_VARIABLE_PASSED_TO_INOUT_FUNCTION_PARAMETER, 129 TEST_ITERATION_INPUT_VS_VARIABLE_PASSED_TO_OUT_FUNCTION_PARAMETER, 130 131 TEST_ITERATION_COUNT 132 } _test_iteration; 133 134 /* Private functions */ 135 void getIterationData(_test_iteration iteration, glu::ApiType *out_required_min_context_type_ptr, 136 _shader_stage *out_target_shader_stage_ptr, std::string *out_body_ptr) const; 137 std::string getIterationName(_test_iteration iteration) const; 138 std::string getShaderStageName(_shader_stage stage) const; 139 140 /* Private members */ 141 glw::GLuint m_fs_id; 142 glw::GLuint m_gs_id; 143 glw::GLuint m_tc_id; 144 glw::GLuint m_te_id; 145 glw::GLuint m_vs_id; 146 }; 147 148 /* Conformance test which verifies that: 149 * 150 * - ! operator does not accept bvec2, bvec3 and bvec4 arguments. 151 * - all() function does not accept a bool argument. 152 * - not() function does not accept a bool argument. 153 */ 154 class InvalidUseCasesForAllNotFuncsAndExclMarkOpTest : public deqp::TestCase 155 { 156 public: 157 /* Public methods */ 158 InvalidUseCasesForAllNotFuncsAndExclMarkOpTest(deqp::Context &context); 159 160 void deinit(); 161 void init(); 162 tcu::TestNode::IterateResult iterate(); 163 164 private: 165 /* Private type declarations */ 166 typedef enum 167 { 168 TEST_ITERATION_FIRST, 169 170 TEST_ITERATION_EXCL_MARK_OP_MUST_NOT_ACCEPT_BVEC2 = TEST_ITERATION_FIRST, 171 TEST_ITERATION_EXCL_MARK_OP_MUST_NOT_ACCEPT_BVEC3, 172 TEST_ITERATION_EXCL_MARK_OP_MUST_NOT_ACCEPT_BVEC4, 173 174 TEST_ITERATION_ALL_FUNC_MUST_NOT_ACCEPT_BOOL, 175 TEST_ITERATION_NOT_FUNC_MUST_NOT_ACCEPT_BOOL, 176 177 TEST_ITERATION_COUNT 178 } _test_iteration; 179 180 /* Private functions */ 181 std::string getIterationName(_test_iteration iteration) const; 182 std::string getShaderBody(_test_iteration iteration) const; 183 184 /* Private members */ 185 glw::GLuint m_vs_id; 186 }; 187 188 /* Conformance test which verifies that all reserved names are rejected by the GL SL compiler 189 * at compilation time, if used as: 190 * 191 * - Block names (input blocks, output blocks, SSBOs, UBOs) 192 * - Function names 193 * - Shader inputs 194 * - Shader outputs 195 * - Structure member name 196 * - Structure names 197 * - Subroutine names 198 * - Uniform names 199 * - Variable names 200 * 201 * in all shader stages supported for GL contexts, starting from GL 3.1. 202 * 203 * Support for all contexts (core profile where applicable) from GL 3.1 204 * up to GL 4.5 is implemented. 205 * */ 206 class ReservedNamesTest : public deqp::TestCase 207 { 208 public: 209 /* Public methods */ 210 ReservedNamesTest(deqp::Context &context); 211 void deinit(); 212 void init(); 213 tcu::TestNode::IterateResult iterate(); 214 215 private: 216 /* Private type declarations */ 217 typedef enum 218 { 219 LANGUAGE_FEATURE_ATOMIC_COUNTER, /* tests usage of incorrectly named atomic counters */ 220 LANGUAGE_FEATURE_ATTRIBUTE, 221 LANGUAGE_FEATURE_CONSTANT, 222 LANGUAGE_FEATURE_FUNCTION_ARGUMENT_NAME, /* tests usage of incorrectly named function argument name */ 223 LANGUAGE_FEATURE_FUNCTION_NAME, /* tests usage of incorrectly named function name */ 224 LANGUAGE_FEATURE_INPUT, 225 LANGUAGE_FEATURE_INPUT_BLOCK_INSTANCE_NAME, /* tests usage of incorrectly named input block instance */ 226 LANGUAGE_FEATURE_INPUT_BLOCK_MEMBER_NAME, /* tests usage of an input block with an incorrectly named member variable */ 227 LANGUAGE_FEATURE_INPUT_BLOCK_NAME, /* tests usage of incorrectly named input block name */ 228 LANGUAGE_FEATURE_OUTPUT, 229 LANGUAGE_FEATURE_OUTPUT_BLOCK_INSTANCE_NAME, /* tests usage of incorrectly named output block instance */ 230 LANGUAGE_FEATURE_OUTPUT_BLOCK_MEMBER_NAME, /* tests usage of an output block with an incorrectly named member variable */ 231 LANGUAGE_FEATURE_OUTPUT_BLOCK_NAME, /* tests usage of incorrectly named output block name */ 232 LANGUAGE_FEATURE_SHADER_STORAGE_BLOCK_INSTANCE_NAME, /* tests usage of incorrectly named shader storage block instance */ 233 LANGUAGE_FEATURE_SHADER_STORAGE_BLOCK_MEMBER_NAME, /* tests usage of a shader storage block with an incorrectly named member variable */ 234 LANGUAGE_FEATURE_SHADER_STORAGE_BLOCK_NAME, /* tests usage of incorrectly named shader storage block name */ 235 LANGUAGE_FEATURE_SHARED_VARIABLE, 236 LANGUAGE_FEATURE_STRUCTURE_MEMBER, /* tests usage of a structure whose member variable is incorrectly named */ 237 LANGUAGE_FEATURE_STRUCTURE_INSTANCE_NAME, /* tests usage of a structure whose instance is incorrectly named */ 238 LANGUAGE_FEATURE_STRUCTURE_NAME, /* tests usage of a structure whose name is incorrect */ 239 LANGUAGE_FEATURE_SUBROUTINE_FUNCTION_NAME, /* tests usage of incorrectly named subroutine functions */ 240 LANGUAGE_FEATURE_SUBROUTINE_TYPE, /* tests usage of incorrectly named subroutine types */ 241 LANGUAGE_FEATURE_SUBROUTINE_UNIFORM, /* tests usage of incorrectly named subroutine uniforms */ 242 LANGUAGE_FEATURE_UNIFORM, /* tests usage of incorrectly named sampler2D uniforms */ 243 LANGUAGE_FEATURE_UNIFORM_BLOCK_INSTANCE_NAME, /* tests usage of incorrectly named shader storage block instance */ 244 LANGUAGE_FEATURE_UNIFORM_BLOCK_MEMBER_NAME, /* tests usage of a shader storage block with an incorrectly named member variable */ 245 LANGUAGE_FEATURE_UNIFORM_BLOCK_NAME, /* tests usage of incorrectly named shader storage block name */ 246 LANGUAGE_FEATURE_VARIABLE, 247 LANGUAGE_FEATURE_VARYING, 248 249 LANGUAGE_FEATURE_COUNT 250 } _language_feature; 251 252 typedef enum 253 { 254 SHADER_TYPE_COMPUTE, 255 SHADER_TYPE_FRAGMENT, 256 SHADER_TYPE_GEOMETRY, 257 SHADER_TYPE_TESS_CONTROL, 258 SHADER_TYPE_TESS_EVALUATION, 259 SHADER_TYPE_VERTEX, 260 261 SHADER_TYPE_COUNT 262 } _shader_type; 263 264 /* Private functions */ 265 std::string getLanguageFeatureName(_language_feature language_feature) const; 266 std::vector<std::string> getReservedNames() const; 267 std::string getShaderBody(_shader_type shader_type, _language_feature language_feature, 268 const char *invalid_name) const; 269 std::string getShaderTypeName(_shader_type shader_type) const; 270 std::vector<_language_feature> getSupportedLanguageFeatures(_shader_type shader_type) const; 271 std::vector<_shader_type> getSupportedShaderTypes() const; 272 bool isStructAllowed(_shader_type shader_type, _language_feature language_feature) const; 273 274 /* Private members */ 275 glw::GLint m_max_fs_ssbos; 276 glw::GLint m_max_gs_acs; 277 glw::GLint m_max_gs_ssbos; 278 glw::GLint m_max_tc_acs; 279 glw::GLint m_max_tc_ssbos; 280 glw::GLint m_max_te_acs; 281 glw::GLint m_max_te_ssbos; 282 glw::GLint m_max_vs_acs; 283 glw::GLint m_max_vs_ssbos; 284 glw::GLuint m_so_ids[SHADER_TYPE_COUNT]; 285 }; 286 287 /* Conformance test which verifies that the following types, used to declare a vertex 288 * shader input variable, result in a compilation-time error: 289 * 290 * - bool, bvec2, bvec3, bvec4 291 * - opaque type 292 * - structure 293 * 294 * The test also verifies that it is illegal to use any of the following qualifiers 295 * for an otherwise valid vertex shader input variable declaration: 296 * 297 * - centroid 298 * - patch 299 * - sample 300 */ 301 class InvalidVSInputsTest : public deqp::TestCase 302 { 303 public: 304 /* Public methods */ 305 InvalidVSInputsTest(deqp::Context &context); 306 307 void deinit(); 308 void init(); 309 tcu::TestNode::IterateResult iterate(); 310 311 private: 312 /* Private type declarations */ 313 typedef enum 314 { 315 TEST_ITERATION_FIRST, 316 317 TEST_ITERATION_INVALID_BOOL_INPUT = TEST_ITERATION_FIRST, 318 TEST_ITERATION_INVALID_BVEC2_INPUT, 319 TEST_ITERATION_INVALID_BVEC3_INPUT, 320 TEST_ITERATION_INVALID_BVEC4_INPUT, 321 TEST_ITERATION_INVALID_CENTROID_QUALIFIED_INPUT, 322 TEST_ITERATION_INVALID_PATCH_QUALIFIED_INPUT, 323 TEST_ITERATION_INVALID_OPAQUE_TYPE_INPUT, 324 TEST_ITERATION_INVALID_STRUCTURE_INPUT, 325 TEST_ITERATION_INVALID_SAMPLE_QUALIFIED_INPUT, 326 327 TEST_ITERATION_COUNT 328 } _test_iteration; 329 330 /* Private functions */ 331 std::string getIterationName(_test_iteration iteration) const; 332 std::string getShaderBody(_test_iteration iteration) const; 333 334 /* Private members */ 335 glw::GLuint m_vs_id; 336 }; 337 338 /* Conformance test which verifies that parenthesis are not accepted in compute shaders, prior to GL4.4, 339 * unless GL_ARB_enhanced_layouts is supported. 340 */ 341 class ParenthesisInLayoutQualifierIntegerValuesTest : public deqp::TestCase 342 { 343 public: 344 /* Public methods */ 345 ParenthesisInLayoutQualifierIntegerValuesTest(deqp::Context &context); 346 347 void deinit(); 348 void init(); 349 tcu::TestNode::IterateResult iterate(); 350 351 private: 352 /* Private members */ 353 glw::GLuint m_cs_id; 354 glw::GLuint m_po_id; 355 }; 356 357 /* Conformance test which verifies that gl_PerVertex block re-declarations are required by 358 * the OpenGL implementation if separate shader object functionality is used. 359 * 360 * Additionally, the test also checks that the following test cases result in an error: 361 * 362 * - Usage of any of the input/output built-in variables in any of the five shader stages, with the 363 * variable not being defined in the re-declared gl_PerVertex block. 364 * - gl_PerVertex block re-declarations defined in a different manner for each of the used shader stages. 365 * 366 * Each test iteration is run in two "modes": 367 * 368 * 1. A pipeline object is created and shader programs are attached to it. It is expected that validation 369 * should fail. 370 * 2. A single separate shader program, to which all shader stages used by the test are attached, is linked. 371 * It is expected the linking process should fail. 372 * 373 */ 374 class PerVertexValidationTest : public deqp::TestCase 375 { 376 public: 377 /* Public methods */ 378 PerVertexValidationTest(deqp::Context &context); 379 380 void deinit(); 381 void init(); 382 tcu::TestNode::IterateResult iterate(); 383 384 private: 385 /* Private type definitions */ 386 typedef enum 387 { 388 SHADER_STAGE_FRAGMENT = 1 << 0, 389 SHADER_STAGE_GEOMETRY = 1 << 1, 390 SHADER_STAGE_TESSELLATION_CONTROL = 1 << 2, 391 SHADER_STAGE_TESSELLATION_EVALUATION = 1 << 3, 392 SHADER_STAGE_VERTEX = 1 << 4 393 } _shader_stage; 394 395 typedef enum 396 { 397 TEST_ITERATION_FIRST, 398 399 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_GS_GL_CLIPDISTANCE_USAGE = TEST_ITERATION_FIRST, 400 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_GS_GL_CULLDISTANCE_USAGE, 401 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_GS_GL_POINTSIZE_USAGE, 402 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_GS_GL_POSITION_USAGE, 403 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TC_GL_CLIPDISTANCE_USAGE, 404 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TC_GL_CULLDISTANCE_USAGE, 405 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TC_GL_POINTSIZE_USAGE, 406 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TC_GL_POSITION_USAGE, 407 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TE_GL_CLIPDISTANCE_USAGE, 408 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TE_GL_CULLDISTANCE_USAGE, 409 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TE_GL_POINTSIZE_USAGE, 410 TEST_ITERATION_UNDECLARED_IN_PERVERTEX_TE_GL_POSITION_USAGE, 411 412 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_GS_GL_CLIPDISTANCE_USAGE, 413 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_GS_GL_CULLDISTANCE_USAGE, 414 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_GS_GL_POINTSIZE_USAGE, 415 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_GS_GL_POSITION_USAGE, 416 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TC_GL_CLIPDISTANCE_USAGE, 417 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TC_GL_CULLDISTANCE_USAGE, 418 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TC_GL_POINTSIZE_USAGE, 419 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TC_GL_POSITION_USAGE, 420 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TE_GL_CLIPDISTANCE_USAGE, 421 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TE_GL_CULLDISTANCE_USAGE, 422 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TE_GL_POINTSIZE_USAGE, 423 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_TE_GL_POSITION_USAGE, 424 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_VS_GL_CLIPDISTANCE_USAGE, 425 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_VS_GL_CULLDISTANCE_USAGE, 426 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_VS_GL_POINTSIZE_USAGE, 427 TEST_ITERATION_UNDECLARED_OUT_PERVERTEX_VS_GL_POSITION_USAGE, 428 429 TEST_ITERATION_PERVERTEX_DECLARATION_MISMATCH_GS_VS, 430 TEST_ITERATION_PERVERTEX_DECLARATION_MISMATCH_GS_TC_TE_VS, 431 TEST_ITERATION_PERVERTEX_DECLARATION_MISMATCH_TC_TE_VS, 432 433 TEST_ITERATION_PERVERTEX_BLOCK_UNDEFINED, 434 435 /* Always last */ 436 TEST_ITERATION_COUNT 437 } _test_iteration; 438 439 typedef enum 440 { 441 VALIDATION_RESULT_FALSE, 442 VALIDATION_RESULT_TRUE, 443 VALIDATION_RESULT_UNDEFINED, 444 } _validation; 445 446 /* Private functions */ 447 void destroyPOsAndSOs(); 448 _validation getProgramPipelineValidationExpectedResult(void) const; 449 std::string getShaderStageName(_shader_stage shader_stage) const; 450 std::string getTestIterationName(_test_iteration iteration) const; 451 452 void getTestIterationProperties(glu::ContextType context_type, _test_iteration iteration, 453 glu::ContextType *out_min_context_type_ptr, 454 _shader_stage *out_used_shader_stages_ptr, std::string *out_gs_body_ptr, 455 std::string *out_tc_body_ptr, std::string *out_te_body_ptr, 456 std::string *out_vs_body_ptr) const; 457 458 std::string getVertexShaderBody(glu::ContextType context_type, _test_iteration iteration, 459 std::string main_body = std::string("gl_Position = vec4(1.0);")) const; 460 461 bool isShaderProgramLinkingFailureExpected(_test_iteration iteration) const; 462 bool runPipelineObjectValidationTestMode(_test_iteration iteration); 463 bool runSeparateShaderTestMode(_test_iteration iteration); 464 465 /* Private members */ 466 glw::GLuint m_fs_id; 467 glw::GLuint m_fs_po_id; 468 glw::GLuint m_gs_id; 469 glw::GLuint m_gs_po_id; 470 glw::GLuint m_pipeline_id; 471 glw::GLuint m_tc_id; 472 glw::GLuint m_tc_po_id; 473 glw::GLuint m_te_id; 474 glw::GLuint m_te_po_id; 475 glw::GLuint m_vs_id; 476 glw::GLuint m_vs_po_id; 477 }; 478 479 /* Conformance test which verifies that glCopyBufferSubData() and glBufferSubData() calls, executed 480 * within a single page boundary, work correctly. The test is ran for a number of consecutive pages, 481 * a predefined number of times, where each pass is separated by a front/back buffer swap operation. 482 */ 483 class SparseBuffersWithCopyOpsTest : public deqp::TestCase 484 { 485 public: 486 /* Public methods */ 487 SparseBuffersWithCopyOpsTest(deqp::Context &context); 488 489 void deinit(); 490 void init(); 491 tcu::TestNode::IterateResult iterate(); 492 493 private: 494 /* Private methods */ 495 bool initTest(); 496 497 /* Private members */ 498 glw::GLuint m_bo_id; 499 glw::GLuint m_bo_read_id; 500 unsigned char *m_clear_buffer; 501 glw::GLint m_page_size; 502 unsigned char m_reference_data[16]; 503 unsigned int m_result_data_storage_size; 504 505 const unsigned int m_n_iterations_to_run; 506 const unsigned int m_n_pages_to_test; 507 const unsigned int m_virtual_bo_size; 508 }; 509 510 /** Test group which encapsulates all "common bugs" conformance tests */ 511 class CommonBugsTests : public deqp::TestCaseGroup 512 { 513 public: 514 /* Public methods */ 515 CommonBugsTests(deqp::Context &context); 516 517 void init(); 518 519 private: 520 CommonBugsTests(const CommonBugsTests &other); 521 CommonBugsTests &operator=(const CommonBugsTests &other); 522 }; 523 } // namespace gl3cts 524 525 #endif // _GL3CCOMMONBUGSTESTS_HPP 526