1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2017 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ /*! 20 * \file glcRobustnessTests.cpp 21 * \brief Conformance tests for the Robustness feature functionality. 22 */ /*-------------------------------------------------------------------*/ 23 24 #include "glcRobustnessTests.hpp" 25 #include "deSharedPtr.hpp" 26 #include "glcRobustBufferAccessBehaviorTests.hpp" 27 #include "gluContextInfo.hpp" 28 #include "gluPlatform.hpp" 29 #include "gluRenderContext.hpp" 30 #include "glwEnums.hpp" 31 #include "glwFunctions.hpp" 32 #include "tcuCommandLine.hpp" 33 #include "tcuTestLog.hpp" 34 #include <cstring> 35 36 using namespace glw; 37 using namespace deqp::RobustBufferAccessBehavior; 38 39 namespace glcts 40 { 41 42 namespace ResetNotificationStrategy 43 { 44 45 class RobustnessBase : public tcu::TestCase 46 { 47 public: 48 RobustnessBase(tcu::TestContext& testCtx, const char* name, const char* description, glu::ApiType apiType); 49 50 glu::RenderContext* createRobustContext(glu::ResetNotificationStrategy reset); 51 52 private: 53 glu::ApiType m_ApiType; 54 }; 55 56 RobustnessBase::RobustnessBase(tcu::TestContext& testCtx, const char* name, const char* description, 57 glu::ApiType apiType) 58 : tcu::TestCase(testCtx, name, description), m_ApiType(apiType) 59 { 60 } 61 62 glu::RenderContext* RobustnessBase::createRobustContext(glu::ResetNotificationStrategy reset) 63 { 64 /* Create test context to verify if GL_KHR_robustness extension is available */ 65 { 66 deqp::Context context(m_testCtx, glu::ContextType(m_ApiType)); 67 if (!context.getContextInfo().isExtensionSupported("GL_KHR_robustness") && 68 !contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 69 { 70 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, 71 "GL_KHR_robustness extension not supported"); 72 return NULL; 73 } 74 } 75 76 glu::RenderConfig renderCfg(glu::ContextType(m_ApiType, glu::CONTEXT_ROBUST)); 77 const tcu::CommandLine& commandLine = m_testCtx.getCommandLine(); 78 glu::parseRenderConfig(&renderCfg, commandLine); 79 80 if (commandLine.getSurfaceType() == tcu::SURFACETYPE_WINDOW) 81 renderCfg.resetNotificationStrategy = reset; 82 else 83 throw tcu::NotSupportedError("Test not supported in non-windowed context"); 84 85 /* Try to create core/es robusness context */ 86 return createRenderContext(m_testCtx.getPlatform(), commandLine, renderCfg); 87 } 88 89 class NoResetNotificationCase : public RobustnessBase 90 { 91 typedef glw::GLenum(GLW_APIENTRY* PFNGLGETGRAPHICSRESETSTATUS)(); 92 93 public: 94 NoResetNotificationCase(tcu::TestContext& testCtx, const char* name, const char* description, glu::ApiType apiType) 95 : RobustnessBase(testCtx, name, description, apiType) 96 { 97 } 98 99 virtual IterateResult iterate(void) 100 { 101 glu::ResetNotificationStrategy strategy = glu::RESET_NOTIFICATION_STRATEGY_NO_RESET_NOTIFICATION; 102 de::SharedPtr<glu::RenderContext> robustContext(createRobustContext(strategy)); 103 if (!robustContext.get()) 104 return STOP; 105 106 PFNGLGETGRAPHICSRESETSTATUS pGetGraphicsResetStatus = 107 (PFNGLGETGRAPHICSRESETSTATUS)robustContext->getProcAddress("glGetGraphicsResetStatus"); 108 109 if (DE_NULL == pGetGraphicsResetStatus) 110 { 111 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, 112 "Pointer to function glGetGraphicsResetStatus is NULL."); 113 return STOP; 114 } 115 116 glw::GLint reset = 0; 117 118 const glw::Functions& gl = robustContext->getFunctions(); 119 gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset); 120 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv"); 121 122 if (reset != GL_NO_RESET_NOTIFICATION) 123 { 124 m_testCtx.getLog() << tcu::TestLog::Message << "Test failed! glGet returned wrong value [" << reset 125 << ", expected " << GL_NO_RESET_NOTIFICATION << "]." << tcu::TestLog::EndMessage; 126 127 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 128 return STOP; 129 } 130 131 glw::GLint status = pGetGraphicsResetStatus(); 132 if (status != GL_NO_ERROR) 133 { 134 m_testCtx.getLog() << tcu::TestLog::Message 135 << "Test failed! glGetGraphicsResetStatus returned wrong value [" << status 136 << ", expected " << GL_NO_ERROR << "]." << tcu::TestLog::EndMessage; 137 138 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 139 return STOP; 140 } 141 142 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 143 return STOP; 144 } 145 }; 146 147 class LoseContextOnResetCase : public RobustnessBase 148 { 149 public: 150 LoseContextOnResetCase(tcu::TestContext& testCtx, const char* name, const char* description, glu::ApiType apiType) 151 : RobustnessBase(testCtx, name, description, apiType) 152 { 153 } 154 155 virtual IterateResult iterate(void) 156 { 157 glu::ResetNotificationStrategy strategy = glu::RESET_NOTIFICATION_STRATEGY_LOSE_CONTEXT_ON_RESET; 158 de::SharedPtr<glu::RenderContext> robustContext(createRobustContext(strategy)); 159 if (!robustContext.get()) 160 return STOP; 161 162 glw::GLint reset = 0; 163 164 const glw::Functions& gl = robustContext->getFunctions(); 165 gl.getIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &reset); 166 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv"); 167 168 if (reset != GL_LOSE_CONTEXT_ON_RESET) 169 { 170 m_testCtx.getLog() << tcu::TestLog::Message << "Test failed! glGet returned wrong value [" << reset 171 << ", expected " << GL_LOSE_CONTEXT_ON_RESET << "]." << tcu::TestLog::EndMessage; 172 173 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 174 return STOP; 175 } 176 177 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 178 return STOP; 179 } 180 }; 181 182 } // ResetNotificationStrategy namespace 183 184 namespace RobustBufferAccessBehavior 185 { 186 187 static deqp::Context* createContext(tcu::TestContext& testCtx, glu::ApiType apiType) 188 { 189 deqp::Context* context = new deqp::Context(testCtx, glu::ContextType(apiType)); 190 if (!context) 191 { 192 testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Pointer to context is NULL."); 193 return DE_NULL; 194 } 195 196 if (!(contextSupports(context->getRenderContext().getType(), glu::ApiType::es(3, 2)) || 197 (context->getContextInfo().isExtensionSupported("GL_KHR_robustness") && 198 context->getContextInfo().isExtensionSupported("GL_KHR_robust_buffer_access_behavior")))) 199 { 200 testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 201 delete context; 202 return DE_NULL; 203 } 204 205 return context; 206 } 207 208 /** Implementation of test GetnUniformTest. Description follows: 209 * 210 * This test verifies if read uniform variables to the buffer with bufSize less than expected result with GL_INVALID_OPERATION error; 211 **/ 212 class GetnUniformTest : public tcu::TestCase 213 { 214 public: 215 /* Public methods */ 216 GetnUniformTest(tcu::TestContext& testCtx, glu::ApiType apiType); 217 virtual ~GetnUniformTest() 218 { 219 } 220 221 /* Public methods inherited from TestCase */ 222 virtual tcu::TestNode::IterateResult iterate(void); 223 224 private: 225 /* Private methods */ 226 std::string getComputeShader(bool glslES320); 227 228 bool verifyResult(const void* inputData, const void* resultData, int size, const char* method); 229 bool verifyError(glw::GLint error, glw::GLint expectedError, const char* method); 230 231 glu::ApiType m_ApiType; 232 }; 233 234 /** Constructor 235 * 236 * @param context Test context 237 **/ 238 GetnUniformTest::GetnUniformTest(tcu::TestContext& testCtx, glu::ApiType apiType) 239 : tcu::TestCase(testCtx, "getnuniform", "Verifies if read uniform variables to the buffer with bufSize less than " 240 "expected result with GL_INVALID_OPERATION") 241 , m_ApiType(apiType) 242 { 243 /* Nothing to be done here */ 244 } 245 246 /** Execute test 247 * 248 * @return tcu::TestNode::STOP 249 **/ 250 tcu::TestNode::IterateResult GetnUniformTest::iterate() 251 { 252 de::SharedPtr<deqp::Context> context(createContext(m_testCtx, m_ApiType)); 253 if (!context.get()) 254 return STOP; 255 256 /* GL funtion pointers. */ 257 typedef void(GLW_APIENTRY * PFNGLGETNUNIFORMFV)(glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, 258 glw::GLfloat * params); 259 typedef void(GLW_APIENTRY * PFNGLGETNUNIFORMIV)(glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, 260 glw::GLint * params); 261 typedef void(GLW_APIENTRY * PFNGLGETNUNIFORMUIV)(glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, 262 glw::GLuint * params); 263 264 /* Function pointers need to be grabbed only for GL4.5 but it is done also for ES for consistency */ 265 glu::RenderContext& renderContext = context->getRenderContext(); 266 PFNGLGETNUNIFORMFV pGetnUniformfv = (PFNGLGETNUNIFORMFV)renderContext.getProcAddress("glGetnUniformfv"); 267 PFNGLGETNUNIFORMIV pGetnUniformiv = (PFNGLGETNUNIFORMIV)renderContext.getProcAddress("glGetnUniformiv"); 268 PFNGLGETNUNIFORMUIV pGetnUniformuiv = (PFNGLGETNUNIFORMUIV)renderContext.getProcAddress("glGetnUniformuiv"); 269 270 if ((DE_NULL == pGetnUniformfv) || (DE_NULL == pGetnUniformiv) || (DE_NULL == pGetnUniformuiv)) 271 { 272 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Pointer to function glGetnUniform* is NULL."); 273 return STOP; 274 } 275 276 const Functions& gl = renderContext.getFunctions(); 277 278 const GLfloat input4f[] = { 1.0f, 5.4f, 3.14159f, 1.28f }; 279 const GLint input3i[] = { 10, -20, -30 }; 280 const GLuint input4ui[] = { 10, 20, 30, 40 }; 281 282 /* Test result indicator */ 283 bool test_result = true; 284 285 /* Iterate over all cases */ 286 Program program(*context); 287 288 /* Compute Shader */ 289 bool glslES320 = contextSupports(renderContext.getType(), glu::ApiType::es(3, 2)); 290 const std::string& cs = getComputeShader(glslES320); 291 292 /* Shaders initialization */ 293 program.Init(cs /* cs */, "" /* fs */, "" /* gs */, "" /* tcs */, "" /* tes */, "" /* vs */); 294 program.Use(); 295 296 /* For gl4.5 use shader storage buffer */ 297 GLuint buf; 298 if (!glslES320) 299 { 300 gl.genBuffers(1, &buf); 301 GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers"); 302 303 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, buf); 304 GLU_EXPECT_NO_ERROR(gl.getError(), "BindBufferBase"); 305 306 gl.bufferData(GL_SHADER_STORAGE_BUFFER, 16, DE_NULL, GL_STREAM_DRAW); 307 GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData"); 308 } 309 310 /* passing uniform values */ 311 gl.programUniform4fv(program.m_id, 11, 1, input4f); 312 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramUniform4fv"); 313 314 gl.programUniform3iv(program.m_id, 12, 1, input3i); 315 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramUniform3iv"); 316 317 gl.programUniform4uiv(program.m_id, 13, 1, input4ui); 318 GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramUniform4uiv"); 319 320 gl.dispatchCompute(1, 1, 1); 321 GLU_EXPECT_NO_ERROR(gl.getError(), "DispatchCompute"); 322 323 /* veryfing gfetnUniform error messages */ 324 GLfloat result4f[4]; 325 GLint result3i[3]; 326 GLuint result4ui[4]; 327 328 pGetnUniformfv(program.m_id, 11, sizeof(GLfloat) * 4, result4f); 329 test_result = test_result && 330 verifyResult((void*)input4f, (void*)result4f, sizeof(GLfloat) * 4, "getnUniformfv [false negative]"); 331 test_result = test_result && verifyError(gl.getError(), GL_NO_ERROR, "getnUniformfv [false negative]"); 332 333 pGetnUniformfv(program.m_id, 11, sizeof(GLfloat) * 3, result4f); 334 test_result = test_result && verifyError(gl.getError(), GL_INVALID_OPERATION, "getnUniformfv [false positive]"); 335 336 pGetnUniformiv(program.m_id, 12, sizeof(GLint) * 3, result3i); 337 test_result = test_result && 338 verifyResult((void*)input3i, (void*)result3i, sizeof(GLint) * 3, "getnUniformiv [false negative]"); 339 test_result = test_result && verifyError(gl.getError(), GL_NO_ERROR, "getnUniformiv [false negative]"); 340 341 pGetnUniformiv(program.m_id, 12, sizeof(GLint) * 2, result3i); 342 test_result = test_result && verifyError(gl.getError(), GL_INVALID_OPERATION, "getnUniformiv [false positive]"); 343 344 pGetnUniformuiv(program.m_id, 13, sizeof(GLuint) * 4, result4ui); 345 test_result = test_result && verifyResult((void*)input4ui, (void*)result4ui, sizeof(GLuint) * 4, 346 "getnUniformuiv [false negative]"); 347 test_result = test_result && verifyError(gl.getError(), GL_NO_ERROR, "getnUniformuiv [false negative]"); 348 349 pGetnUniformuiv(program.m_id, 13, sizeof(GLuint) * 3, result4ui); 350 test_result = test_result && verifyError(gl.getError(), GL_INVALID_OPERATION, "getnUniformuiv [false positive]"); 351 352 /* Set result */ 353 if (true == test_result) 354 { 355 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 356 } 357 else 358 { 359 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 360 } 361 362 if (!glslES320) 363 { 364 gl.deleteBuffers(1, &buf); 365 } 366 367 /* Done */ 368 return tcu::TestNode::STOP; 369 } 370 371 std::string GetnUniformTest::getComputeShader(bool glslES320) 372 { 373 std::stringstream shader; 374 shader << "#version " << (glslES320 ? "320 es\n" : "450\n"); 375 shader << "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 376 "layout (location = 11) uniform vec4 inputf;\n" 377 "layout (location = 12) uniform ivec3 inputi;\n" 378 "layout (location = 13) uniform uvec4 inputu;\n"; 379 if (glslES320) 380 { 381 shader << "shared float valuef;\n" 382 "shared int valuei;\n" 383 "shared uint valueu;\n"; 384 } 385 else 386 { 387 shader << "layout (std140, binding = 0) buffer ssbo {" 388 " float valuef;\n" 389 " int valuei;\n" 390 " uint valueu;\n" 391 "};\n"; 392 } 393 shader << "void main()\n" 394 "{\n" 395 " valuef = inputf.r + inputf.g + inputf.b + inputf.a;\n" 396 " valuei = inputi.r + inputi.g + inputi.b;\n" 397 " valueu = inputu.r + inputu.g + inputu.b + inputu.a;\n" 398 "}\n"; 399 400 return shader.str(); 401 } 402 403 bool GetnUniformTest::verifyResult(const void* inputData, const void* resultData, int size, const char* method) 404 { 405 int diff = memcmp(inputData, resultData, size); 406 if (diff != 0) 407 { 408 m_testCtx.getLog() << tcu::TestLog::Message << "Test failed! " << method << " result is not as expected." 409 << tcu::TestLog::EndMessage; 410 411 return false; 412 } 413 414 return true; 415 } 416 417 bool GetnUniformTest::verifyError(GLint error, GLint expectedError, const char* method) 418 { 419 if (error != expectedError) 420 { 421 m_testCtx.getLog() << tcu::TestLog::Message << "Test failed! " << method << " throws unexpected error [" 422 << error << "]." << tcu::TestLog::EndMessage; 423 424 return false; 425 } 426 427 return true; 428 } 429 430 /** Implementation of test ReadnPixelsTest. Description follows: 431 * 432 * This test verifies if read pixels to the buffer with bufSize less than expected result with GL_INVALID_OPERATION error; 433 **/ 434 class ReadnPixelsTest : public tcu::TestCase 435 { 436 public: 437 /* Public methods */ 438 ReadnPixelsTest(tcu::TestContext& testCtx, glu::ApiType apiType); 439 virtual ~ReadnPixelsTest() 440 { 441 } 442 443 /* Public methods inherited from TestCase */ 444 virtual tcu::TestNode::IterateResult iterate(void); 445 446 private: 447 /* Private methods */ 448 void cleanTexture(deqp::Context& context, glw::GLuint texture_id); 449 bool verifyResults(deqp::Context& context); 450 bool verifyError(glw::GLint error, glw::GLint expectedError, const char* method); 451 452 glu::ApiType m_ApiType; 453 }; 454 455 /** Constructor 456 * 457 * @param context Test context 458 **/ 459 ReadnPixelsTest::ReadnPixelsTest(tcu::TestContext& testCtx, glu::ApiType apiType) 460 : tcu::TestCase(testCtx, "readnpixels", 461 "Verifies if read pixels to the buffer with bufSize less than expected result " 462 "with GL_INVALID_OPERATION error") 463 , m_ApiType(apiType) 464 { 465 /* Nothing to be done here */ 466 } 467 468 /** Execute test 469 * 470 * @return tcu::TestNode::STOP 471 **/ 472 tcu::TestNode::IterateResult ReadnPixelsTest::iterate() 473 { 474 de::SharedPtr<deqp::Context> context(createContext(m_testCtx, m_ApiType)); 475 if (!context.get()) 476 return STOP; 477 478 /* GL funtion pointers. */ 479 typedef void(GLW_APIENTRY * PFNGLREADNPIXELS)(glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height, 480 glw::GLenum format, glw::GLenum type, glw::GLsizei bufSize, 481 glw::GLvoid * data); 482 483 PFNGLREADNPIXELS pReadnPixels = (PFNGLREADNPIXELS)context->getRenderContext().getProcAddress("glReadnPixels"); 484 485 if (DE_NULL == pReadnPixels) 486 { 487 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Pointer to function glReadnPixels is NULL."); 488 return STOP; 489 } 490 491 static const GLuint elements[] = { 492 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 7, 0, 7, 8, 0, 8, 1, 493 }; 494 495 static const GLfloat vertices[] = { 496 0.0f, 0.0f, 0.0f, 1.0f, /* 0 */ 497 -1.0f, 0.0f, 0.0f, 1.0f, /* 1 */ 498 -1.0f, 1.0f, 0.0f, 1.0f, /* 2 */ 499 0.0f, 1.0f, 0.0f, 1.0f, /* 3 */ 500 1.0f, 1.0f, 0.0f, 1.0f, /* 4 */ 501 1.0f, 0.0f, 0.0f, 1.0f, /* 5 */ 502 1.0f, -1.0f, 0.0f, 1.0f, /* 6 */ 503 0.0f, -1.0f, 0.0f, 1.0f, /* 7 */ 504 -1.0f, -1.0f, 0.0f, 1.0f, /* 8 */ 505 }; 506 507 bool glslES320 = contextSupports(context->getRenderContext().getType(), glu::ApiType::es(3, 2)); 508 std::string fs("#version "); 509 fs += (glslES320 ? "320 es\n" : "450\n"); 510 fs += "layout (location = 0) out lowp uvec4 out_fs_color;\n" 511 "\n" 512 "void main()\n" 513 "{\n" 514 " out_fs_color = uvec4(1, 0, 0, 1);\n" 515 "}\n" 516 "\n"; 517 518 std::string vs("#version "); 519 vs += (glslES320 ? "320 es\n" : "450\n"); 520 vs += "layout (location = 0) in vec4 in_vs_position;\n" 521 "\n" 522 "void main()\n" 523 "{\n" 524 " gl_Position = in_vs_position;\n" 525 "}\n" 526 "\n"; 527 528 static const GLuint height = 8; 529 static const GLuint width = 8; 530 static const GLuint n_vertices = 24; 531 532 /* GL entry points */ 533 const Functions& gl = context->getRenderContext().getFunctions(); 534 535 /* Test case objects */ 536 Program program(*context); 537 Texture texture(*context); 538 Buffer elements_buffer(*context); 539 Buffer vertices_buffer(*context); 540 VertexArray vao(*context); 541 542 /* Vertex array initialization */ 543 VertexArray::Generate(gl, vao.m_id); 544 VertexArray::Bind(gl, vao.m_id); 545 546 /* Texture initialization */ 547 Texture::Generate(gl, texture.m_id); 548 Texture::Bind(gl, texture.m_id, GL_TEXTURE_2D); 549 Texture::Storage(gl, GL_TEXTURE_2D, 1, GL_R8UI, width, height, 0); 550 Texture::Bind(gl, 0, GL_TEXTURE_2D); 551 552 /* Framebuffer initialization */ 553 GLuint fbo; 554 gl.genFramebuffers(1, &fbo); 555 GLU_EXPECT_NO_ERROR(gl.getError(), "GenFramebuffers"); 556 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); 557 GLU_EXPECT_NO_ERROR(gl.getError(), "BindFramebuffer"); 558 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.m_id, 0); 559 GLU_EXPECT_NO_ERROR(gl.getError(), "FramebufferTexture2D"); 560 561 /* Buffers initialization */ 562 elements_buffer.InitData(GL_ELEMENT_ARRAY_BUFFER, GL_DYNAMIC_DRAW, sizeof(elements), elements); 563 vertices_buffer.InitData(GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW, sizeof(vertices), vertices); 564 565 /* Shaders initialization */ 566 program.Init("" /* cs */, fs, "" /* gs */, "" /* tcs */, "" /* tes */, vs); 567 Program::Use(gl, program.m_id); 568 569 /* Vertex buffer initialization */ 570 vertices_buffer.Bind(); 571 gl.bindVertexBuffer(0 /* bindindex = location */, vertices_buffer.m_id, 0 /* offset */, 16 /* stride */); 572 gl.vertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 16, NULL); 573 gl.enableVertexAttribArray(0 /* location */); 574 575 /* Binding elements/indices buffer */ 576 elements_buffer.Bind(); 577 578 cleanTexture(*context, texture.m_id); 579 580 gl.drawElements(GL_TRIANGLES, n_vertices, GL_UNSIGNED_INT, 0 /* indices */); 581 GLU_EXPECT_NO_ERROR(gl.getError(), "DrawElements"); 582 583 /* Set result */ 584 if (verifyResults(*context)) 585 { 586 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 587 } 588 else 589 { 590 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 591 } 592 593 /* Done */ 594 return tcu::TestNode::STOP; 595 } 596 597 /** Fill texture with value 128 598 * 599 * @param texture_id Id of texture 600 **/ 601 void ReadnPixelsTest::cleanTexture(deqp::Context& context, glw::GLuint texture_id) 602 { 603 static const GLuint height = 8; 604 static const GLuint width = 8; 605 606 const Functions& gl = context.getRenderContext().getFunctions(); 607 608 GLubyte pixels[width * height]; 609 for (GLuint i = 0; i < width * height; ++i) 610 { 611 pixels[i] = 64; 612 } 613 614 Texture::Bind(gl, texture_id, GL_TEXTURE_2D); 615 616 Texture::SubImage(gl, GL_TEXTURE_2D, 0 /* level */, 0 /* x */, 0 /* y */, 0 /* z */, width, height, 0 /* depth */, 617 GL_RED_INTEGER, GL_UNSIGNED_BYTE, pixels); 618 619 /* Unbind */ 620 Texture::Bind(gl, 0, GL_TEXTURE_2D); 621 } 622 623 /** Verifies glReadnPixels results 624 * 625 * @return true when glReadnPixels , false otherwise 626 **/ 627 bool ReadnPixelsTest::verifyResults(deqp::Context& context) 628 { 629 static const GLuint height = 8; 630 static const GLuint width = 8; 631 static const GLuint pixel_size = 4 * sizeof(GLuint); 632 633 const Functions& gl = context.getRenderContext().getFunctions(); 634 635 //Valid buffer size test 636 const GLint bufSizeValid = width * height * pixel_size; 637 GLubyte pixelsValid[bufSizeValid]; 638 639 gl.readnPixels(0, 0, width, height, GL_RGBA_INTEGER, GL_UNSIGNED_INT, bufSizeValid, pixelsValid); 640 GLU_EXPECT_NO_ERROR(gl.getError(), "ReadnPixels"); 641 642 //Verify glReadnPixels result 643 for (unsigned int i = 0; i < width * height; ++i) 644 { 645 const size_t offset = i * pixel_size; 646 const GLuint value = *(GLuint*)(pixelsValid + offset); 647 648 if (value != 1) 649 { 650 context.getTestContext().getLog() << tcu::TestLog::Message << "Invalid pixel value: " << value 651 << ". Offset: " << offset << tcu::TestLog::EndMessage; 652 return false; 653 } 654 } 655 656 //Invalid buffer size test 657 const GLint bufSizeInvalid = width * height * pixel_size - 1; 658 GLubyte pixelsInvalid[bufSizeInvalid]; 659 660 gl.readnPixels(0, 0, width, height, GL_RGBA_INTEGER, GL_UNSIGNED_INT, bufSizeInvalid, pixelsInvalid); 661 if (!verifyError(gl.getError(), GL_INVALID_OPERATION, "ReadnPixels [false positive]")) 662 return false; 663 664 return true; 665 } 666 667 /** Verify operation errors 668 * 669 * @param error OpenGL ES error code 670 * @param expectedError Expected error code 671 * @param method Method name marker 672 * 673 * @return true when error is as expected, false otherwise 674 **/ 675 bool ReadnPixelsTest::verifyError(GLint error, GLint expectedError, const char* method) 676 { 677 if (error != expectedError) 678 { 679 m_testCtx.getLog() << tcu::TestLog::Message << "Test failed! " << method << " throws unexpected error [" 680 << error << "]." << tcu::TestLog::EndMessage; 681 682 return false; 683 } 684 685 return true; 686 } 687 688 } // RobustBufferAccessBehavior namespace 689 690 RobustnessTests::RobustnessTests(tcu::TestContext& testCtx, glu::ApiType apiType) 691 : tcu::TestCaseGroup(testCtx, "robustness", 692 "Verifies API coverage and functionality of GL_KHR_robustness extension.") 693 , m_ApiType(apiType) 694 { 695 } 696 697 void RobustnessTests::init(void) 698 { 699 tcu::TestCaseGroup::init(); 700 701 try 702 { 703 addChild(new ResetNotificationStrategy::NoResetNotificationCase( 704 m_testCtx, "no_reset_notification", "Verifies if NO_RESET_NOTIFICATION strategy works as expected.", 705 m_ApiType)); 706 addChild(new ResetNotificationStrategy::LoseContextOnResetCase( 707 m_testCtx, "lose_context_on_reset", "Verifies if LOSE_CONTEXT_ON_RESET strategy works as expected.", 708 m_ApiType)); 709 710 addChild(new RobustBufferAccessBehavior::GetnUniformTest(m_testCtx, m_ApiType)); 711 addChild(new RobustBufferAccessBehavior::ReadnPixelsTest(m_testCtx, m_ApiType)); 712 } 713 catch (...) 714 { 715 // Destroy context. 716 tcu::TestCaseGroup::deinit(); 717 throw; 718 } 719 } 720 721 } // glcts namespace 722
