1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2015-2016 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ /*! 20 * \file 21 * \brief 22 */ /*-------------------------------------------------------------------*/ 23 24 /** 25 */ /*! 26 * \file gl4cDirectStateAccessBuffersTests.cpp 27 * \brief Conformance tests for the Direct State Access feature functionality (Buffer access part). 28 */ /*-----------------------------------------------------------------------------------------------------------*/ 29 30 /* Includes. */ 31 #include "gl4cDirectStateAccessTests.hpp" 32 33 #include "deSharedPtr.hpp" 34 35 #include "gluContextInfo.hpp" 36 #include "gluDefs.hpp" 37 #include "gluPixelTransfer.hpp" 38 #include "gluStrUtil.hpp" 39 40 #include "tcuFuzzyImageCompare.hpp" 41 #include "tcuImageCompare.hpp" 42 #include "tcuRenderTarget.hpp" 43 #include "tcuSurface.hpp" 44 #include "tcuTestLog.hpp" 45 46 #include "glw.h" 47 #include "glwFunctions.hpp" 48 49 #include <algorithm> 50 #include <climits> 51 #include <set> 52 #include <sstream> 53 #include <stack> 54 #include <string> 55 56 /* Scripts have not generated this enum (GL_NV_gpu_multicast / GL_NVX_linked_gpu_multicast is not in the registry gl.xml?). */ 57 #ifndef GL_PER_GPU_STORAGE_BIT_NV 58 #define GL_PER_GPU_STORAGE_BIT_NV 0x0800 59 #endif 60 61 namespace gl4cts 62 { 63 namespace DirectStateAccess 64 { 65 namespace Buffers 66 { 67 /******************************** Creation Test Implementation ********************************/ 68 69 /** @brief Creation Test constructor. 70 * 71 * @param [in] context OpenGL context. 72 */ 73 CreationTest::CreationTest(deqp::Context& context) 74 : deqp::TestCase(context, "buffers_creation", "Buffer Objects Creation Test") 75 { 76 /* Intentionally left blank. */ 77 } 78 79 /** @brief Iterate Creation Test cases. 80 * 81 * @return Iteration result. 82 */ 83 tcu::TestNode::IterateResult CreationTest::iterate() 84 { 85 /* Shortcut for GL functionality. */ 86 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 87 88 /* Get context setup. */ 89 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 90 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 91 92 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 93 { 94 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 95 96 return STOP; 97 } 98 99 /* Running tests. */ 100 bool is_ok = true; 101 bool is_error = false; 102 103 /* Buffers' objects */ 104 static const glw::GLuint buffers_count = 2; 105 106 glw::GLuint buffers_legacy[buffers_count] = {}; 107 glw::GLuint buffers_dsa[buffers_count] = {}; 108 109 try 110 { 111 /* Check legacy state creation. */ 112 gl.genBuffers(buffers_count, buffers_legacy); 113 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers have failed"); 114 115 for (glw::GLuint i = 0; i < buffers_count; ++i) 116 { 117 if (gl.isBuffer(buffers_legacy[i])) 118 { 119 is_ok = false; 120 121 /* Log. */ 122 m_context.getTestContext().getLog() 123 << tcu::TestLog::Message 124 << "GenBuffers has created default objects, but it should create only a names." 125 << tcu::TestLog::EndMessage; 126 } 127 } 128 129 /* Check direct state creation. */ 130 gl.createBuffers(buffers_count, buffers_dsa); 131 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers have failed"); 132 133 for (glw::GLuint i = 0; i < buffers_count; ++i) 134 { 135 if (!gl.isBuffer(buffers_dsa[i])) 136 { 137 is_ok = false; 138 139 /* Log. */ 140 m_context.getTestContext().getLog() << tcu::TestLog::Message 141 << "CreateBuffers has not created default objects." 142 << tcu::TestLog::EndMessage; 143 } 144 } 145 } 146 catch (...) 147 { 148 is_ok = false; 149 is_error = true; 150 } 151 152 /* Cleanup. */ 153 for (glw::GLuint i = 0; i < buffers_count; ++i) 154 { 155 if (buffers_legacy[i]) 156 { 157 gl.deleteBuffers(1, &buffers_legacy[i]); 158 159 buffers_legacy[i] = 0; 160 } 161 162 if (buffers_dsa[i]) 163 { 164 gl.deleteBuffers(1, &buffers_dsa[i]); 165 166 buffers_dsa[i] = 0; 167 } 168 } 169 170 /* Errors clean up. */ 171 while (gl.getError()) 172 ; 173 174 /* Result's setup. */ 175 if (is_ok) 176 { 177 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 178 } 179 else 180 { 181 if (is_error) 182 { 183 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 184 } 185 else 186 { 187 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 188 } 189 } 190 191 return STOP; 192 } 193 194 /******************************** Data Test Implementation ********************************/ 195 196 /** @brief Data Test constructor. 197 * 198 * @param [in] context OpenGL context. 199 */ 200 DataTest::DataTest(deqp::Context& context) 201 : deqp::TestCase(context, "buffers_data", "Buffer Objects Data Test") 202 , m_pNamedBufferData(DE_NULL) 203 , m_pNamedBufferSubData(DE_NULL) 204 , m_pNamedBufferStorage(DE_NULL) 205 , m_pCopyNamedBufferSubData(DE_NULL) 206 { 207 /* Intentionally left blank. */ 208 } 209 210 /** @brief Iterate Data Test cases. 211 * 212 * @return Iteration result. 213 */ 214 tcu::TestNode::IterateResult DataTest::iterate() 215 { 216 /* Shortcut for GL functionality. */ 217 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 218 219 /* Get context setup. */ 220 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 221 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 222 223 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 224 { 225 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 226 227 return STOP; 228 } 229 230 /* Running tests. */ 231 bool is_ok = true; 232 bool is_error = false; 233 234 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 235 m_pNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATA)gl.namedBufferSubData; 236 m_pNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGE)gl.namedBufferStorage; 237 m_pCopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATA)gl.copyNamedBufferSubData; 238 239 try 240 { 241 if ((DE_NULL == m_pNamedBufferData) || (DE_NULL == m_pNamedBufferSubData) || 242 (DE_NULL == m_pNamedBufferStorage) || (DE_NULL == m_pCopyNamedBufferSubData)) 243 { 244 throw 0; 245 } 246 247 /* BufferData tests */ 248 static const glw::GLenum hints[] = { GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, 249 GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, 250 GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, GL_DYNAMIC_COPY }; 251 static const glw::GLuint hints_count = sizeof(hints) / sizeof(hints[0]); 252 253 for (glw::GLuint i = 0; i < hints_count; ++i) 254 { 255 is_ok &= TestCase(&DataTest::UploadUsingNamedBufferData, hints[i]); 256 is_ok &= TestCase(&DataTest::UploadUsingNamedBufferSubData, hints[i]); 257 is_ok &= TestCase(&DataTest::UploadUsingCopyNamedBufferSubData, hints[i]); 258 } 259 260 /* BufferStorage Tests */ 261 static const glw::GLenum bits[] = { GL_MAP_READ_BIT | GL_DYNAMIC_STORAGE_BIT, 262 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT, GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT, 263 GL_MAP_READ_BIT | GL_MAP_COHERENT_BIT | GL_MAP_PERSISTENT_BIT, 264 GL_MAP_READ_BIT | GL_CLIENT_STORAGE_BIT }; 265 static const glw::GLuint bits_count = sizeof(bits) / sizeof(bits[0]); 266 267 for (glw::GLuint i = 0; i < bits_count; ++i) 268 { 269 is_ok &= TestCase(&DataTest::UploadUsingNamedBufferStorage, bits[i]); 270 } 271 } 272 catch (...) 273 { 274 is_ok = false; 275 is_error = true; 276 } 277 278 /* Errors clean up. */ 279 while (gl.getError()) 280 ; 281 282 /* Result's setup. */ 283 if (is_ok) 284 { 285 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 286 } 287 else 288 { 289 if (is_error) 290 { 291 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 292 } 293 else 294 { 295 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 296 } 297 } 298 299 return STOP; 300 } 301 302 /** @brief Data uploading test case function. 303 * 304 * @param [in] UploadDataFunction Function pointer to the tested data uploading function. 305 * @param [in] parameter Storage Parameter to be used with the function (function dependent). 306 * 307 * @return True if test case succeeded, false otherwise. 308 */ 309 bool DataTest::TestCase(void (DataTest::*UploadDataFunction)(glw::GLuint, glw::GLenum), glw::GLenum parameter) 310 { 311 /* Shortcut for GL functionality. */ 312 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 313 314 glw::GLuint buffer = 0; 315 bool is_ok = true; 316 bool is_error = false; 317 318 try 319 { 320 gl.createBuffers(1, &buffer); 321 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 322 323 (this->*UploadDataFunction)(buffer, parameter); 324 325 gl.bindBuffer(GL_ARRAY_BUFFER, buffer); 326 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer failed."); 327 328 glw::GLuint* data = (glw::GLuint*)gl.mapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY); 329 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer failed."); 330 331 is_ok = compare(data, s_reference, s_reference_count); 332 333 if (!is_ok) 334 { 335 LogFail(UploadDataFunction, parameter, data, s_reference, s_reference_count); 336 } 337 338 gl.unmapBuffer(GL_ARRAY_BUFFER); 339 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer failed."); 340 } 341 catch (...) 342 { 343 is_ok = false; 344 is_error = true; 345 346 LogError(UploadDataFunction, parameter); 347 } 348 349 if (buffer) 350 { 351 gl.deleteBuffers(1, &buffer); 352 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers failed."); 353 } 354 355 if (is_error) 356 { 357 throw 0; 358 } 359 360 return is_ok; 361 } 362 363 /** @brief NamedBufferData data upload function. 364 * 365 * @param [in] id Buffer id to be uploaded. 366 * @param [in] parameter Storage Parameter to be used with the function, one of: 367 * - GL_STREAM_DRAW, 368 * - GL_STREAM_READ, 369 * - GL_STREAM_COPY, 370 * - GL_STATIC_DRAW, 371 * - GL_STATIC_READ, 372 * - GL_STATIC_COPY, 373 * - GL_DYNAMIC_DRAW, 374 * - GL_DYNAMIC_READ and 375 * - GL_DYNAMIC_COPY. 376 */ 377 void DataTest::UploadUsingNamedBufferData(glw::GLuint id, glw::GLenum parameter) 378 { 379 /* Shortcut for GL functionality. */ 380 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 381 382 m_pNamedBufferData(id, s_reference_size, s_reference, parameter); 383 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 384 } 385 386 /** @brief NamedBufferSubData data upload function. 387 * 388 * @param [in] id Buffer id to be uploaded. 389 * @param [in] parameter Storage parameter to be used with the NamedBufferData for 390 * the storage allocation (before call to NamedBufferSubData), one of: 391 * - GL_STREAM_DRAW, 392 * - GL_STREAM_READ, 393 * - GL_STREAM_COPY, 394 * - GL_STATIC_DRAW, 395 * - GL_STATIC_READ, 396 * - GL_STATIC_COPY, 397 * - GL_DYNAMIC_DRAW, 398 * - GL_DYNAMIC_READ and 399 * - GL_DYNAMIC_COPY. 400 */ 401 void DataTest::UploadUsingNamedBufferSubData(glw::GLuint id, glw::GLenum parameter) 402 { 403 /* Shortcut for GL functionality. */ 404 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 405 406 m_pNamedBufferData(id, s_reference_size, DE_NULL, parameter); 407 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 408 409 m_pNamedBufferSubData(id, 0, s_reference_size, s_reference); 410 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferSubData failed."); 411 } 412 413 /** @brief NamedBufferStorage data upload function. 414 * 415 * @param [in] id Buffer id to be uploaded. 416 * @param [in] parameter Storage Parameter to be used with the function, one of: 417 * - GL_MAP_READ_BIT | GL_DYNAMIC_STORAGE_BIT, 418 * - GL_MAP_READ_BIT | GL_MAP_WRITE_BIT, 419 * - GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT, 420 * - GL_MAP_READ_BIT | GL_MAP_COHERENT_BIT, 421 * - GL_MAP_READ_BIT | GL_CLIENT_STORAGE_BIT 422 */ 423 void DataTest::UploadUsingNamedBufferStorage(glw::GLuint id, glw::GLenum parameter) 424 { 425 /* Shortcut for GL functionality. */ 426 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 427 428 m_pNamedBufferStorage(id, s_reference_size, s_reference, parameter); 429 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferStorage failed."); 430 } 431 432 /** @brief CopyNamedBufferSubData data upload function (uses auxiliary buffer object). 433 * 434 * @param [in] id Buffer id to be uploaded. 435 * @param [in] parameter Storage parameter to be used with the NamedBufferData for 436 * the auxiliary buffer object storage allocation 437 * (before call to CopyNamedBufferSubData), one of: 438 * - GL_STREAM_DRAW, 439 * - GL_STREAM_READ, 440 * - GL_STREAM_COPY, 441 * - GL_STATIC_DRAW, 442 * - GL_STATIC_READ, 443 * - GL_STATIC_COPY, 444 * - GL_DYNAMIC_DRAW, 445 * - GL_DYNAMIC_READ and 446 * - GL_DYNAMIC_COPY. 447 */ 448 void DataTest::UploadUsingCopyNamedBufferSubData(glw::GLuint id, glw::GLenum parameter) 449 { 450 /* Shortcut for GL functionality. */ 451 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 452 453 m_pNamedBufferData(id, s_reference_size, DE_NULL, parameter); 454 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 455 456 glw::GLuint auxiliary_buffer = 0; 457 bool auxiliary_buffer_is_ok = true; 458 459 try 460 { 461 gl.genBuffers(1, &auxiliary_buffer); 462 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers failed."); 463 464 gl.bindBuffer(GL_ARRAY_BUFFER, auxiliary_buffer); 465 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer failed."); 466 467 gl.bufferData(GL_ARRAY_BUFFER, s_reference_size, s_reference, parameter); 468 GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData failed."); 469 470 m_pCopyNamedBufferSubData(auxiliary_buffer, id, 0, 0, s_reference_size); 471 GLU_EXPECT_NO_ERROR(gl.getError(), "glCopyNamedBufferSubData failed."); 472 } 473 catch (...) 474 { 475 auxiliary_buffer_is_ok = false; 476 } 477 478 if (auxiliary_buffer) 479 { 480 gl.deleteBuffers(1, &auxiliary_buffer); 481 } 482 483 if (!auxiliary_buffer_is_ok) 484 { 485 throw 0; 486 } 487 } 488 489 /** @brief Compare two unsigned integer arrays. 490 * 491 * @param [in] data Data to be compared. 492 * @param [in] reference Reference data to be compared to. 493 * @param [in] count Number of elements to be compared. 494 * 495 * @return True if count of data the elements are equal to reference counterparts, false otherwise. 496 */ 497 bool DataTest::compare(const glw::GLuint* data, const glw::GLuint* reference, const glw::GLsizei count) 498 { 499 for (glw::GLsizei i = 0; i < count; ++i) 500 { 501 if (data[i] != reference[i]) 502 { 503 return false; 504 } 505 } 506 return true; 507 } 508 509 /** @brief Prepare error message and log it. 510 * 511 * @param [in] UploadDataFunction Upload function pointer which have failed, one of: 512 * - DataTest::UploadUsingNamedBufferData, 513 * - DataTest::UploadUsingNamedBufferSubData 514 * - DataTest::UploadUsingNamedBufferStorage and 515 * - DataTest::UploadUsingCopyNamedBufferSubData. 516 * @param [in] parameter Parameter which was passed to function. 517 * @param [in] data Data which was downloaded. 518 * @param [in] reference Reference data. 519 * @param [in] count Number of elements compared. 520 */ 521 void DataTest::LogFail(void (DataTest::*UploadDataFunction)(glw::GLuint, glw::GLenum), glw::GLenum parameter, 522 const glw::GLuint* data, const glw::GLuint* reference, const glw::GLsizei count) 523 { 524 std::string the_log = "The test of "; 525 526 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferData) 527 { 528 the_log.append("glNamedBufferData"); 529 } 530 else 531 { 532 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferSubData) 533 { 534 the_log.append("glNamedBufferSubData"); 535 } 536 else 537 { 538 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferStorage) 539 { 540 the_log.append("glNamedBufferStorage"); 541 } 542 else 543 { 544 if (UploadDataFunction == &DataTest::UploadUsingCopyNamedBufferSubData) 545 { 546 the_log.append("glCopyNamedBufferSubData"); 547 } 548 else 549 { 550 the_log.append("uknown upload function"); 551 } 552 } 553 } 554 } 555 556 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferStorage) 557 { 558 the_log.append(" called with usage parameter "); 559 560 std::stringstream bitfield_string_stream; 561 bitfield_string_stream << glu::getBufferMapFlagsStr(parameter); 562 the_log.append(bitfield_string_stream.str()); 563 } 564 else 565 { 566 the_log.append(" called with usage parameter "); 567 the_log.append(glu::getUsageName(parameter)); 568 } 569 the_log.append(". Buffer data is equal to ["); 570 571 for (glw::GLsizei i = 0; i < count; ++i) 572 { 573 std::stringstream number; 574 575 number << data[i]; 576 577 the_log.append(number.str()); 578 579 if (i != count - 1) 580 { 581 the_log.append(", "); 582 } 583 } 584 585 the_log.append("], but ["); 586 587 for (glw::GLsizei i = 0; i < count; ++i) 588 { 589 std::stringstream number; 590 591 number << reference[i]; 592 593 the_log.append(number.str()); 594 595 if (i != count - 1) 596 { 597 the_log.append(", "); 598 } 599 } 600 601 the_log.append("] was expected."); 602 603 m_context.getTestContext().getLog() << tcu::TestLog::Message << the_log << tcu::TestLog::EndMessage; 604 } 605 606 void DataTest::LogError(void (DataTest::*UploadDataFunction)(glw::GLuint, glw::GLenum), glw::GLenum parameter) 607 { 608 std::string the_log = "Unexpected error occurred during the test of "; 609 610 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferData) 611 { 612 the_log.append("glNamedBufferData"); 613 } 614 else 615 { 616 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferSubData) 617 { 618 the_log.append("glNamedBufferSubData"); 619 } 620 else 621 { 622 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferStorage) 623 { 624 the_log.append("glNamedBufferStorage"); 625 } 626 else 627 { 628 if (UploadDataFunction == &DataTest::UploadUsingCopyNamedBufferSubData) 629 { 630 the_log.append("glCopyNamedBufferSubData"); 631 } 632 else 633 { 634 the_log.append("uknown upload function"); 635 } 636 } 637 } 638 } 639 640 if (UploadDataFunction == &DataTest::UploadUsingNamedBufferStorage) 641 { 642 the_log.append(" called with usage parameter "); 643 644 std::stringstream bitfield_string_stream; 645 bitfield_string_stream << glu::getBufferMapFlagsStr(parameter); 646 the_log.append(bitfield_string_stream.str()); 647 } 648 else 649 { 650 the_log.append(" called with usage parameter "); 651 the_log.append(glu::getUsageName(parameter)); 652 } 653 the_log.append("."); 654 655 m_context.getTestContext().getLog() << tcu::TestLog::Message << the_log << tcu::TestLog::EndMessage; 656 } 657 658 const glw::GLuint DataTest::s_reference[] = { 659 0, 1, 2, 4, 8, 16, 64, 128, 256, 512, 1024, 2048, 4096 660 }; //!< Reference data. 661 const glw::GLsizei DataTest::s_reference_size = sizeof(s_reference); //!< Size of the reference data. 662 const glw::GLsizei DataTest::s_reference_count = 663 s_reference_size / sizeof(s_reference[0]); //!< NUmber of elements of the reference data. 664 665 /******************************** Clear Test Implementation ********************************/ 666 667 /** @brief Data Test constructor. 668 * 669 * @param [in] context OpenGL context. 670 */ 671 ClearTest::ClearTest(deqp::Context& context) 672 : deqp::TestCase(context, "buffers_clear", "Buffer Objects Clear Test") 673 , m_pNamedBufferData(DE_NULL) 674 , m_pClearNamedBufferData(DE_NULL) 675 , m_pClearNamedBufferSubData(DE_NULL) 676 { 677 /* Intentionally left blank. */ 678 } 679 680 /** @brief ClearNamedBufferData wrapper implementation. 681 * 682 * @note USE_SUB_DATA == false, so ClearNamedBufferData will be used. 683 * 684 * @param [in] buffer ID of the buffer to be cleared. 685 * @param [in] internalformat GL internal format for clearing, one of the listed in test class description. 686 * @param [in] size Size of the data. 687 * @param [in] format GL Format of the data. 688 * @param [in] type GL Type of the data element. 689 * @param [in] data Data to be cleared with. 690 */ 691 template <> 692 void ClearTest::ClearNamedBuffer<false>(glw::GLuint buffer, glw::GLenum internalformat, glw::GLsizei size, 693 glw::GLenum format, glw::GLenum type, glw::GLvoid* data) 694 { 695 (void)size; 696 /* Shortcut for GL functionality. */ 697 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 698 699 m_pClearNamedBufferData(buffer, internalformat, format, type, data); 700 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearNamedBufferData failed."); 701 } 702 703 /** @brief ClearNamedBufferSubData wrapper implementation. 704 * 705 * @note USE_SUB_DATA == true, so ClearNamedBufferSubData will be used. 706 * 707 * @param [in] buffer ID of the buffer to be cleared. 708 * @param [in] internalformat GL internal format for clearing, one of the listed in test class description. 709 * @param [in] size Size of the data. 710 * @param [in] format GL Format of the data. 711 * @param [in] type GL Type of the data element. 712 * @param [in] data Data to be cleared with. 713 */ 714 template <> 715 void ClearTest::ClearNamedBuffer<true>(glw::GLuint buffer, glw::GLenum internalformat, glw::GLsizei size, 716 glw::GLenum format, glw::GLenum type, glw::GLvoid* data) 717 { 718 /* Shortcut for GL functionality. */ 719 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 720 721 m_pClearNamedBufferSubData(buffer, internalformat, 0, size, format, type, data); 722 GLU_EXPECT_NO_ERROR(gl.getError(), "glClearNamedBufferData failed."); 723 } 724 725 /** @brief Compare two arrays with elements of type T == GLfloat (specialized). 726 * 727 * @param [in] data Data to be compared. 728 * @param [in] reference Reference data to be compared to. 729 * @param [in] count Number of elements to be compared. 730 * 731 * @return True if count of data the elements are equal to reference counterparts, false otherwise. 732 */ 733 template <> 734 bool ClearTest::Compare<glw::GLfloat>(const glw::GLfloat* data, const glw::GLfloat* reference, const glw::GLsizei count) 735 { 736 for (glw::GLsizei i = 0; i < count; ++i) 737 { 738 if (de::abs(data[i] - reference[i]) > 0.00001 /* Precision. */) 739 { 740 return false; 741 } 742 } 743 return true; 744 } 745 746 /** @brief Compare two arrays with elements of type T. 747 * 748 * @tparam T Type of data to be compared (anything which is not GLfloat. 749 * Floating point numbers have another specialized implementation, 750 * which accounts the precision issues. 751 * 752 * @param [in] data Data to be compared. 753 * @param [in] reference Reference data to be compared to. 754 * @param [in] count Number of elements to be compared. 755 * 756 * @return True if count of data the elements are equal to reference counterparts, false otherwise. 757 */ 758 template <typename T> 759 bool ClearTest::Compare(const T* data, const T* reference, const glw::GLsizei count) 760 { 761 for (glw::GLsizei i = 0; i < count; ++i) 762 { 763 if (data[i] != reference[i]) 764 { 765 return false; 766 } 767 } 768 return true; 769 } 770 771 /** @brief Prepare error message and log it. 772 * 773 * @tparam T Type of data to which was tested. 774 * 775 * @param [in] internalformat Internal format used for clearing, one of the listed in test class description. 776 * @param [in] data Data which was used for clear test. 777 * @param [in] reference Reference data. 778 * @param [in] count Number of elements to be compared. 779 */ 780 template <typename T> 781 void ClearTest::LogFail(bool use_sub_data, glw::GLenum internalformat, const T* data, const T* reference, 782 const glw::GLsizei count) 783 { 784 (void)internalformat; 785 std::string the_log = "The test of "; 786 787 if (use_sub_data) 788 { 789 the_log.append("ClearNamedBufferSubData has failed for internalformat "); 790 } 791 else 792 { 793 the_log.append("ClearNamedBufferData has failed for internalformat "); 794 } 795 796 //the_log.append(glu::getPixelFormatName(internalformat)); 797 the_log.append(". Cleared buffer data is equal to ["); 798 799 for (glw::GLsizei i = 0; i < count; ++i) 800 { 801 std::stringstream number; 802 803 number << data[i]; 804 805 the_log.append(number.str()); 806 807 if (i != count - 1) 808 { 809 the_log.append(", "); 810 } 811 } 812 813 the_log.append("], but ["); 814 815 for (glw::GLsizei i = 0; i < count; ++i) 816 { 817 std::stringstream number; 818 819 number << reference[i]; 820 821 the_log.append(number.str()); 822 823 if (i != count - 1) 824 { 825 the_log.append(", "); 826 } 827 } 828 829 the_log.append("] was expected."); 830 831 m_context.getTestContext().getLog() << tcu::TestLog::Message << the_log << tcu::TestLog::EndMessage; 832 } 833 834 void ClearTest::LogError(bool use_sub_data, glw::GLenum internalformat) 835 { 836 (void)internalformat; 837 std::string the_log = "Unexpected error occurred during Test of "; 838 839 if (use_sub_data) 840 { 841 the_log.append("ClearNamedBufferSubData with internalformat "); 842 } 843 else 844 { 845 the_log.append("ClearNamedBufferData with internalformat "); 846 } 847 848 //the_log.append(glu::getPixelFormatName(internalformat)); 849 850 m_context.getTestContext().getLog() << tcu::TestLog::Message << the_log << tcu::TestLog::EndMessage; 851 } 852 853 /** @brief Run CLearing test case. 854 * 855 * @tparam T Type of data to which to be tested. 856 * @tparam USE_SUB_DATA If true ClearNamedBufferSubData will be used, ClearNamedBufferData otherwise. 857 * 858 * @param [in] internalformat Internal format used for clearing, one of the listed in test class description. 859 * @param [in] count Number of elements. 860 * @param [in] internalformat Data format to be used for clearing. 861 * @param [in] data Data to be used with clear test. 862 * 863 * @return True if test case succeeded, false otherwise. 864 */ 865 template <typename T, bool USE_SUB_DATA> 866 bool ClearTest::TestClearNamedBufferData(glw::GLenum internalformat, glw::GLsizei count, glw::GLenum format, 867 glw::GLenum type, T* data) 868 { 869 /* Shortcut for GL functionality. */ 870 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 871 872 glw::GLuint buffer = 0; 873 bool is_ok = true; 874 bool is_error = false; 875 876 try 877 { 878 gl.createBuffers(1, &buffer); 879 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 880 881 m_pNamedBufferData(buffer, static_cast<glw::GLsizei>(count * sizeof(T)), NULL, GL_DYNAMIC_COPY); 882 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 883 884 ClearNamedBuffer<USE_SUB_DATA>(buffer, internalformat, static_cast<glw::GLsizei>(count * sizeof(T)), format, 885 type, data); 886 887 gl.bindBuffer(GL_ARRAY_BUFFER, buffer); 888 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer failed."); 889 890 T* _data = (T*)gl.mapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY); 891 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer failed."); 892 893 is_ok = Compare<T>(_data, data, count); 894 895 if (!is_ok) 896 { 897 /* Log. */ 898 LogFail<T>(USE_SUB_DATA, internalformat, _data, data, count); 899 } 900 901 gl.unmapBuffer(GL_ARRAY_BUFFER); 902 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer failed."); 903 } 904 catch (...) 905 { 906 is_ok = false; 907 is_error = true; 908 909 LogError(USE_SUB_DATA, internalformat); 910 } 911 912 if (buffer) 913 { 914 gl.deleteBuffers(1, &buffer); 915 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers failed."); 916 } 917 918 if (is_error) 919 { 920 throw 0; 921 } 922 923 return is_ok; 924 } 925 926 /** @brief Iterate Data Test cases. 927 * 928 * @return Iteration result. 929 */ 930 tcu::TestNode::IterateResult ClearTest::iterate() 931 { 932 /* Shortcut for GL functionality. */ 933 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 934 935 /* Get context setup. */ 936 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 937 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 938 939 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 940 { 941 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 942 943 return STOP; 944 } 945 946 /* Running tests. */ 947 bool is_ok = true; 948 bool is_error = false; 949 950 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 951 m_pClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATA)gl.clearNamedBufferData; 952 m_pClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATA)gl.clearNamedBufferSubData; 953 954 try 955 { 956 if ((DE_NULL == m_pNamedBufferData) || (DE_NULL == m_pClearNamedBufferData) || 957 (DE_NULL == m_pClearNamedBufferSubData)) 958 { 959 throw 0; 960 } 961 962 { 963 /* unsigned byte norm component ClearNamedBufferData tests */ 964 glw::GLubyte reference[4] = { 5, 1, 2, 3 }; 965 966 is_ok &= TestClearNamedBufferData<glw::GLubyte, false>(GL_R8, 1, GL_RED, GL_UNSIGNED_BYTE, reference); 967 is_ok &= TestClearNamedBufferData<glw::GLubyte, false>(GL_RG8, 2, GL_RG, GL_UNSIGNED_BYTE, reference); 968 is_ok &= TestClearNamedBufferData<glw::GLubyte, false>(GL_RGBA8, 4, GL_RGBA, GL_UNSIGNED_BYTE, reference); 969 970 /* unsigned byte norm component ClearNamedBufferSubData tests */ 971 is_ok &= TestClearNamedBufferData<glw::GLubyte, true>(GL_R8, 1, GL_RED, GL_UNSIGNED_BYTE, reference); 972 is_ok &= TestClearNamedBufferData<glw::GLubyte, true>(GL_RG8, 2, GL_RG, GL_UNSIGNED_BYTE, reference); 973 is_ok &= TestClearNamedBufferData<glw::GLubyte, true>(GL_RGBA8, 4, GL_RGBA, GL_UNSIGNED_BYTE, reference); 974 975 /* unsigned byte component ClearNamedBufferData tests */ 976 is_ok &= TestClearNamedBufferData<glw::GLubyte, false>(GL_R8UI, 1, GL_RED_INTEGER, GL_UNSIGNED_BYTE, reference); 977 is_ok &= TestClearNamedBufferData<glw::GLubyte, false>(GL_RG8UI, 2, GL_RG_INTEGER, GL_UNSIGNED_BYTE, reference); 978 is_ok &= TestClearNamedBufferData<glw::GLubyte, false>(GL_RGBA8UI, 4, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, reference); 979 980 /* unsigned byte component ClearNamedBufferSubData tests */ 981 is_ok &= TestClearNamedBufferData<glw::GLubyte, true>(GL_R8UI, 1, GL_RED_INTEGER, GL_UNSIGNED_BYTE, reference); 982 is_ok &= TestClearNamedBufferData<glw::GLubyte, true>(GL_RG8UI, 2, GL_RG_INTEGER, GL_UNSIGNED_BYTE, reference); 983 is_ok &= TestClearNamedBufferData<glw::GLubyte, true>(GL_RGBA8UI, 4, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, reference); 984 } 985 986 { 987 /* signed byte component ClearNamedBufferData tests */ 988 glw::GLbyte reference[4] = { 5, 1, -2, 3 }; 989 990 is_ok &= TestClearNamedBufferData<glw::GLbyte, false>(GL_R8I, 1, GL_RED_INTEGER, GL_BYTE, reference); 991 is_ok &= TestClearNamedBufferData<glw::GLbyte, false>(GL_RG8I, 2, GL_RG_INTEGER, GL_BYTE, reference); 992 is_ok &= TestClearNamedBufferData<glw::GLbyte, false>(GL_RGBA8I, 4, GL_RGBA_INTEGER, GL_BYTE, reference); 993 994 /* signed byte component ClearNamedBufferSubData tests */ 995 is_ok &= TestClearNamedBufferData<glw::GLbyte, true>(GL_R8I, 1, GL_RED_INTEGER, GL_BYTE, reference); 996 is_ok &= TestClearNamedBufferData<glw::GLbyte, true>(GL_RG8I, 2, GL_RG_INTEGER, GL_BYTE, reference); 997 is_ok &= TestClearNamedBufferData<glw::GLbyte, true>(GL_RGBA8I, 4, GL_RGBA_INTEGER, GL_BYTE, reference); 998 } 999 1000 { 1001 /* unsigned short norm component ClearNamedBufferData tests */ 1002 glw::GLushort reference[4] = { 5, 1, 2, 3 }; 1003 1004 is_ok &= TestClearNamedBufferData<glw::GLushort, false>(GL_R16, 1, GL_RED, GL_UNSIGNED_SHORT, reference); 1005 is_ok &= TestClearNamedBufferData<glw::GLushort, false>(GL_RG16, 2, GL_RG, GL_UNSIGNED_SHORT, reference); 1006 is_ok &= 1007 TestClearNamedBufferData<glw::GLushort, false>(GL_RGBA16, 4, GL_RGBA, GL_UNSIGNED_SHORT, reference); 1008 1009 /* unsigned short norm component ClearNamedBufferSubData tests */ 1010 is_ok &= TestClearNamedBufferData<glw::GLushort, true>(GL_R16, 1, GL_RED, GL_UNSIGNED_SHORT, reference); 1011 is_ok &= TestClearNamedBufferData<glw::GLushort, true>(GL_RG16, 2, GL_RG, GL_UNSIGNED_SHORT, reference); 1012 is_ok &= TestClearNamedBufferData<glw::GLushort, true>(GL_RGBA16, 4, GL_RGBA, GL_UNSIGNED_SHORT, reference); 1013 1014 /* unsigned short component ClearNamedBufferData tests */ 1015 is_ok &= TestClearNamedBufferData<glw::GLushort, false>(GL_R16UI, 1, GL_RED_INTEGER, GL_UNSIGNED_SHORT, reference); 1016 is_ok &= TestClearNamedBufferData<glw::GLushort, false>(GL_RG16UI, 2, GL_RG_INTEGER, GL_UNSIGNED_SHORT, reference); 1017 is_ok &= 1018 TestClearNamedBufferData<glw::GLushort, false>(GL_RGBA16UI, 4, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, reference); 1019 1020 /* unsigned short component ClearNamedBufferSubData tests */ 1021 is_ok &= TestClearNamedBufferData<glw::GLushort, true>(GL_R16UI, 1, GL_RED_INTEGER, GL_UNSIGNED_SHORT, reference); 1022 is_ok &= TestClearNamedBufferData<glw::GLushort, true>(GL_RG16UI, 2, GL_RG_INTEGER, GL_UNSIGNED_SHORT, reference); 1023 is_ok &= 1024 TestClearNamedBufferData<glw::GLushort, true>(GL_RGBA16UI, 4, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, reference); 1025 } 1026 1027 { 1028 /* signed short component ClearNamedBufferData tests */ 1029 glw::GLshort reference[4] = { 5, 1, -2, 3 }; 1030 1031 is_ok &= TestClearNamedBufferData<glw::GLshort, false>(GL_R16I, 1, GL_RED_INTEGER, GL_SHORT, reference); 1032 is_ok &= TestClearNamedBufferData<glw::GLshort, false>(GL_RG16I, 2, GL_RG_INTEGER, GL_SHORT, reference); 1033 is_ok &= TestClearNamedBufferData<glw::GLshort, false>(GL_RGBA16I, 4, GL_RGBA_INTEGER, GL_SHORT, reference); 1034 1035 /* signed short component ClearNamedBufferSubData tests */ 1036 is_ok &= TestClearNamedBufferData<glw::GLshort, true>(GL_R16I, 1, GL_RED_INTEGER, GL_SHORT, reference); 1037 is_ok &= TestClearNamedBufferData<glw::GLshort, true>(GL_RG16I, 2, GL_RG_INTEGER, GL_SHORT, reference); 1038 is_ok &= TestClearNamedBufferData<glw::GLshort, true>(GL_RGBA16I, 4, GL_RGBA_INTEGER, GL_SHORT, reference); 1039 } 1040 1041 { 1042 /* unsigned int component ClearNamedBufferData tests */ 1043 glw::GLuint reference[4] = { 5, 1, 2, 3 }; 1044 1045 is_ok &= TestClearNamedBufferData<glw::GLuint, false>(GL_R32UI, 1, GL_RED_INTEGER, GL_UNSIGNED_INT, reference); 1046 is_ok &= TestClearNamedBufferData<glw::GLuint, false>(GL_RG32UI, 2, GL_RG_INTEGER, GL_UNSIGNED_INT, reference); 1047 is_ok &= TestClearNamedBufferData<glw::GLuint, false>(GL_RGB32UI, 3, GL_RGB_INTEGER, GL_UNSIGNED_INT, reference); 1048 is_ok &= TestClearNamedBufferData<glw::GLuint, false>(GL_RGBA32UI, 4, GL_RGBA_INTEGER, GL_UNSIGNED_INT, reference); 1049 1050 /* unsigned int component ClearNamedBufferSubData tests */ 1051 is_ok &= TestClearNamedBufferData<glw::GLuint, true>(GL_R32UI, 1, GL_RED_INTEGER, GL_UNSIGNED_INT, reference); 1052 is_ok &= TestClearNamedBufferData<glw::GLuint, true>(GL_RG32UI, 2, GL_RG_INTEGER, GL_UNSIGNED_INT, reference); 1053 is_ok &= TestClearNamedBufferData<glw::GLuint, true>(GL_RGB32UI, 3, GL_RGB_INTEGER, GL_UNSIGNED_INT, reference); 1054 is_ok &= TestClearNamedBufferData<glw::GLuint, true>(GL_RGBA32UI, 4, GL_RGBA_INTEGER, GL_UNSIGNED_INT, reference); 1055 } 1056 1057 { 1058 /* signed int component ClearNamedBufferData tests */ 1059 glw::GLint reference[4] = { 5, 1, -2, 3 }; 1060 1061 is_ok &= TestClearNamedBufferData<glw::GLint, false>(GL_R32I, 1, GL_RED_INTEGER, GL_INT, reference); 1062 is_ok &= TestClearNamedBufferData<glw::GLint, false>(GL_RG32I, 2, GL_RG_INTEGER, GL_INT, reference); 1063 is_ok &= TestClearNamedBufferData<glw::GLint, false>(GL_RGB32I, 3, GL_RGB_INTEGER, GL_INT, reference); 1064 is_ok &= TestClearNamedBufferData<glw::GLint, false>(GL_RGBA32I, 4, GL_RGBA_INTEGER, GL_INT, reference); 1065 1066 /* signed int component ClearNamedBufferSubData tests */ 1067 is_ok &= TestClearNamedBufferData<glw::GLint, true>(GL_R32I, 1, GL_RED_INTEGER, GL_INT, reference); 1068 is_ok &= TestClearNamedBufferData<glw::GLint, true>(GL_RG32I, 2, GL_RG_INTEGER, GL_INT, reference); 1069 is_ok &= TestClearNamedBufferData<glw::GLint, true>(GL_RGB32I, 3, GL_RGB_INTEGER, GL_INT, reference); 1070 is_ok &= TestClearNamedBufferData<glw::GLint, true>(GL_RGBA32I, 4, GL_RGBA_INTEGER, GL_INT, reference); 1071 } 1072 1073 { 1074 /* half float component ClearNamedBufferData tests */ 1075 glw::GLhalf reference[4] = { 0x3C00 /* 1.0hf */, 0x0000 /* 0.0hf */, 0xC000 /* -2.0hf */, 1076 0x3555 /* 0.333333333hf */ }; 1077 1078 is_ok &= TestClearNamedBufferData<glw::GLhalf, false>(GL_R16F, 1, GL_RED, GL_HALF_FLOAT, reference); 1079 is_ok &= TestClearNamedBufferData<glw::GLhalf, false>(GL_RG16F, 2, GL_RG, GL_HALF_FLOAT, reference); 1080 is_ok &= TestClearNamedBufferData<glw::GLhalf, false>(GL_RGBA16F, 4, GL_RGBA, GL_HALF_FLOAT, reference); 1081 1082 /* half float component ClearNamedBufferSubData tests */ 1083 is_ok &= TestClearNamedBufferData<glw::GLhalf, true>(GL_R16F, 1, GL_RED, GL_HALF_FLOAT, reference); 1084 is_ok &= TestClearNamedBufferData<glw::GLhalf, true>(GL_RG16F, 2, GL_RG, GL_HALF_FLOAT, reference); 1085 is_ok &= TestClearNamedBufferData<glw::GLhalf, true>(GL_RGBA16F, 4, GL_RGBA, GL_HALF_FLOAT, reference); 1086 } 1087 1088 { 1089 /* float component ClearNamedBufferData tests */ 1090 glw::GLfloat reference[4] = { 1.f, 0.f, -2.f, 0.3333333333f }; 1091 1092 is_ok &= TestClearNamedBufferData<glw::GLfloat, false>(GL_R32F, 1, GL_RED, GL_FLOAT, reference); 1093 is_ok &= TestClearNamedBufferData<glw::GLfloat, false>(GL_RG32F, 2, GL_RG, GL_FLOAT, reference); 1094 is_ok &= TestClearNamedBufferData<glw::GLfloat, false>(GL_RGB32F, 3, GL_RGB, GL_FLOAT, reference); 1095 is_ok &= TestClearNamedBufferData<glw::GLfloat, false>(GL_RGBA32F, 4, GL_RGBA, GL_FLOAT, reference); 1096 1097 /* float component ClearNamedBufferSubData tests */ 1098 is_ok &= TestClearNamedBufferData<glw::GLfloat, true>(GL_R32F, 1, GL_RED, GL_FLOAT, reference); 1099 is_ok &= TestClearNamedBufferData<glw::GLfloat, true>(GL_RG32F, 2, GL_RG, GL_FLOAT, reference); 1100 is_ok &= TestClearNamedBufferData<glw::GLfloat, true>(GL_RGB32F, 3, GL_RGB, GL_FLOAT, reference); 1101 is_ok &= TestClearNamedBufferData<glw::GLfloat, true>(GL_RGBA32F, 4, GL_RGBA, GL_FLOAT, reference); 1102 } 1103 } 1104 catch (...) 1105 { 1106 is_ok = false; 1107 is_error = true; 1108 } 1109 1110 /* Errors clean up. */ 1111 while (gl.getError()) 1112 ; 1113 1114 /* Result's setup. */ 1115 if (is_ok) 1116 { 1117 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1118 } 1119 else 1120 { 1121 if (is_error) 1122 { 1123 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 1124 } 1125 else 1126 { 1127 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1128 } 1129 } 1130 1131 return STOP; 1132 } 1133 1134 /******************************** Map Read Only Test Implementation ********************************/ 1135 1136 /** @brief Map Read Only Test constructor. 1137 * 1138 * @param [in] context OpenGL context. 1139 */ 1140 MapReadOnlyTest::MapReadOnlyTest(deqp::Context& context) 1141 : deqp::TestCase(context, "buffers_map_read_only", "Buffer Objects Map Read Only Test") 1142 , m_pNamedBufferData(DE_NULL) 1143 , m_pMapNamedBuffer(DE_NULL) 1144 , m_pUnmapNamedBuffer(DE_NULL) 1145 { 1146 /* Intentionally left blank. */ 1147 } 1148 1149 /** @brief Iterate Map Read Only Test cases. 1150 * 1151 * @return Iteration result. 1152 */ 1153 tcu::TestNode::IterateResult MapReadOnlyTest::iterate() 1154 { 1155 /* Shortcut for GL functionality. */ 1156 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1157 1158 /* Get context setup. */ 1159 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 1160 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 1161 1162 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 1163 { 1164 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 1165 1166 return STOP; 1167 } 1168 1169 /* Running tests. */ 1170 bool is_ok = true; 1171 bool is_error = false; 1172 1173 glw::GLuint buffer = 0; 1174 1175 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 1176 m_pMapNamedBuffer = (PFNGLMAPNAMEDBUFFER)gl.mapNamedBuffer; 1177 m_pUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFER)gl.unmapNamedBuffer; 1178 1179 try 1180 { 1181 if ((DE_NULL == m_pNamedBufferData) || (DE_NULL == m_pMapNamedBuffer) || (DE_NULL == m_pUnmapNamedBuffer)) 1182 { 1183 throw 0; 1184 } 1185 1186 /* Buffer creation. */ 1187 gl.createBuffers(1, &buffer); 1188 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 1189 1190 /* Buffer's storage allocation and reference data upload. */ 1191 m_pNamedBufferData(buffer, s_reference_size, s_reference, GL_DYNAMIC_COPY); 1192 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 1193 1194 /* Mapping with new named buffer map function. */ 1195 glw::GLuint* data = (glw::GLuint*)m_pMapNamedBuffer(buffer, GL_READ_ONLY); 1196 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 1197 1198 if (DE_NULL == data) 1199 { 1200 /* Log. */ 1201 m_context.getTestContext().getLog() 1202 << tcu::TestLog::Message << "glMapNamedBuffer returned NULL pointer, but buffer's data was expected." 1203 << tcu::TestLog::EndMessage; 1204 } 1205 else 1206 { 1207 /* Comparison results with reference data. */ 1208 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 1209 { 1210 is_ok &= (data[i] == s_reference[i]); 1211 } 1212 1213 if (!is_ok) 1214 { 1215 /* Log. */ 1216 m_context.getTestContext().getLog() 1217 << tcu::TestLog::Message 1218 << "glMapNamedBuffer returned pointer to data which is not identical to reference data." 1219 << tcu::TestLog::EndMessage; 1220 } 1221 1222 /* Unmapping with new named buffer unmap function. */ 1223 if (GL_TRUE != m_pUnmapNamedBuffer(buffer)) 1224 { 1225 is_ok = false; 1226 1227 /* Log. */ 1228 m_context.getTestContext().getLog() 1229 << tcu::TestLog::Message 1230 << "glUnmapNamedBuffer called on mapped buffer has returned GL_FALSE, but GL_TRUE was expected." 1231 << tcu::TestLog::EndMessage; 1232 } 1233 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1234 } 1235 } 1236 catch (...) 1237 { 1238 is_ok = false; 1239 is_error = true; 1240 } 1241 1242 /* Clean up. */ 1243 if (buffer) 1244 { 1245 gl.deleteBuffers(1, &buffer); 1246 1247 buffer = false; 1248 } 1249 1250 /* Errors clean up. */ 1251 while (gl.getError()) 1252 ; 1253 1254 /* Result's setup. */ 1255 if (is_ok) 1256 { 1257 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1258 } 1259 else 1260 { 1261 if (is_error) 1262 { 1263 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 1264 } 1265 else 1266 { 1267 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1268 } 1269 } 1270 1271 return STOP; 1272 } 1273 1274 const glw::GLuint MapReadOnlyTest::s_reference[] = { 0, 1, 2, 4, 8, 16, 64, 128, 256, 512, 1024, 2048, 4096 }; 1275 const glw::GLsizei MapReadOnlyTest::s_reference_size = sizeof(s_reference); 1276 const glw::GLsizei MapReadOnlyTest::s_reference_count = s_reference_size / sizeof(s_reference[0]); 1277 1278 /******************************** Map Read Write Test Implementation ********************************/ 1279 1280 /** @brief Map Read Write Test constructor. 1281 * 1282 * @param [in] context OpenGL context. 1283 */ 1284 MapReadWriteTest::MapReadWriteTest(deqp::Context& context) 1285 : deqp::TestCase(context, "buffers_map_read_write", "Buffer Objects Map Read Write Test") 1286 , m_pNamedBufferData(DE_NULL) 1287 , m_pMapNamedBuffer(DE_NULL) 1288 , m_pUnmapNamedBuffer(DE_NULL) 1289 { 1290 /* Intentionally left blank. */ 1291 } 1292 1293 /** @brief Iterate Map Read Write Test cases. 1294 * 1295 * @return Iteration result. 1296 */ 1297 tcu::TestNode::IterateResult MapReadWriteTest::iterate() 1298 { 1299 /* Shortcut for GL functionality. */ 1300 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1301 1302 /* Get context setup. */ 1303 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 1304 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 1305 1306 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 1307 { 1308 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 1309 1310 return STOP; 1311 } 1312 1313 /* Running tests. */ 1314 bool is_ok = true; 1315 bool is_error = false; 1316 1317 glw::GLuint buffer = 0; 1318 1319 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 1320 m_pMapNamedBuffer = (PFNGLMAPNAMEDBUFFER)gl.mapNamedBuffer; 1321 m_pUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFER)gl.unmapNamedBuffer; 1322 1323 try 1324 { 1325 if ((DE_NULL == m_pNamedBufferData) || (DE_NULL == m_pMapNamedBuffer) || (DE_NULL == m_pUnmapNamedBuffer)) 1326 { 1327 throw 0; 1328 } 1329 1330 /* Buffer creation. */ 1331 gl.createBuffers(1, &buffer); 1332 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 1333 1334 /* Buffer's storage allocation and reference data upload. */ 1335 m_pNamedBufferData(buffer, s_reference_size, s_reference, GL_DYNAMIC_COPY); 1336 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 1337 1338 /* Mapping with new named buffer map function. */ 1339 glw::GLuint* data = (glw::GLuint*)m_pMapNamedBuffer(buffer, GL_READ_WRITE); 1340 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 1341 1342 if (DE_NULL == data) 1343 { 1344 /* Log. */ 1345 m_context.getTestContext().getLog() 1346 << tcu::TestLog::Message << "glMapNamedBuffer returned NULL pointer, but buffer's data was expected." 1347 << tcu::TestLog::EndMessage; 1348 } 1349 else 1350 { 1351 /* Comparison results with reference data. */ 1352 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 1353 { 1354 is_ok &= (data[i] == s_reference[i]); 1355 } 1356 1357 if (!is_ok) 1358 { 1359 /* Log. */ 1360 m_context.getTestContext().getLog() 1361 << tcu::TestLog::Message 1362 << "glMapNamedBuffer returned pointer to data which is not identical to reference data." 1363 << tcu::TestLog::EndMessage; 1364 } 1365 1366 /* Writting inverted reference data. */ 1367 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 1368 { 1369 data[i] = s_reference[s_reference_count - i - 1]; 1370 } 1371 1372 /* Unmapping with new named buffer unmap function. */ 1373 if (GL_TRUE != m_pUnmapNamedBuffer(buffer)) 1374 { 1375 is_ok = false; 1376 1377 /* Log. */ 1378 m_context.getTestContext().getLog() 1379 << tcu::TestLog::Message 1380 << "glUnmapNamedBuffer called on mapped buffer has returned GL_FALSE, but GL_TRUE was expected." 1381 << tcu::TestLog::EndMessage; 1382 } 1383 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1384 1385 data = DE_NULL; 1386 1387 data = (glw::GLuint*)m_pMapNamedBuffer(buffer, GL_READ_WRITE); 1388 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 1389 1390 if (DE_NULL == data) 1391 { 1392 /* Log. */ 1393 m_context.getTestContext().getLog() 1394 << tcu::TestLog::Message 1395 << "glMapNamedBuffer returned NULL pointer, but buffer's data was expected." 1396 << tcu::TestLog::EndMessage; 1397 } 1398 else 1399 { 1400 /* Comparison results with inverted reference data. */ 1401 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 1402 { 1403 is_ok &= (data[i] == s_reference[s_reference_count - i - 1]); 1404 } 1405 1406 /* Unmapping with new named buffer unmap function. */ 1407 if (GL_TRUE != m_pUnmapNamedBuffer(buffer)) 1408 { 1409 is_ok = false; 1410 1411 /* Log. */ 1412 m_context.getTestContext().getLog() 1413 << tcu::TestLog::Message 1414 << "glUnmapNamedBuffer called on mapped buffer has returned GL_FALSE, but GL_TRUE was expected." 1415 << tcu::TestLog::EndMessage; 1416 } 1417 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1418 } 1419 } 1420 } 1421 catch (...) 1422 { 1423 is_ok = false; 1424 is_error = true; 1425 } 1426 1427 /* Clean up. */ 1428 if (buffer) 1429 { 1430 gl.deleteBuffers(1, &buffer); 1431 1432 buffer = false; 1433 } 1434 1435 /* Errors clean up. */ 1436 while (gl.getError()) 1437 ; 1438 1439 /* Result's setup. */ 1440 if (is_ok) 1441 { 1442 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1443 } 1444 else 1445 { 1446 if (is_error) 1447 { 1448 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 1449 } 1450 else 1451 { 1452 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1453 } 1454 } 1455 1456 return STOP; 1457 } 1458 1459 const glw::GLuint MapReadWriteTest::s_reference[] = { 1460 0, 1, 2, 4, 8, 16, 64, 128, 256, 512, 1024, 2048, 4096 1461 }; //!< Reference data. 1462 const glw::GLsizei MapReadWriteTest::s_reference_size = sizeof(s_reference); //!< Reference data size. 1463 const glw::GLsizei MapReadWriteTest::s_reference_count = 1464 s_reference_size / sizeof(s_reference[0]); //!< Reference data elements' count. 1465 1466 /******************************** Map Write Only Test Implementation ********************************/ 1467 1468 /** @brief Map Write Only Test constructor. 1469 * 1470 * @param [in] context OpenGL context. 1471 */ 1472 MapWriteOnlyTest::MapWriteOnlyTest(deqp::Context& context) 1473 : deqp::TestCase(context, "buffers_map_write_only", "Buffer Objects Map Write Only Test") 1474 , m_pNamedBufferData(DE_NULL) 1475 , m_pMapNamedBuffer(DE_NULL) 1476 , m_pUnmapNamedBuffer(DE_NULL) 1477 { 1478 /* Intentionally left blank. */ 1479 } 1480 1481 /** @brief Iterate Map Write Only Test cases. 1482 * 1483 * @return Iteration result. 1484 */ 1485 tcu::TestNode::IterateResult MapWriteOnlyTest::iterate() 1486 { 1487 /* Shortcut for GL functionality. */ 1488 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1489 1490 /* Get context setup. */ 1491 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 1492 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 1493 1494 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 1495 { 1496 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 1497 1498 return STOP; 1499 } 1500 1501 /* Running tests. */ 1502 bool is_ok = true; 1503 bool is_error = false; 1504 1505 glw::GLuint buffer = 0; 1506 1507 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 1508 m_pMapNamedBuffer = (PFNGLMAPNAMEDBUFFER)gl.mapNamedBuffer; 1509 m_pUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFER)gl.unmapNamedBuffer; 1510 1511 try 1512 { 1513 if ((DE_NULL == m_pNamedBufferData) || (DE_NULL == m_pMapNamedBuffer) || (DE_NULL == m_pUnmapNamedBuffer)) 1514 { 1515 throw 0; 1516 } 1517 1518 /* Buffer creation. */ 1519 gl.createBuffers(1, &buffer); 1520 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 1521 1522 /* Buffer's storage allocation. */ 1523 m_pNamedBufferData(buffer, s_reference_size, NULL, GL_DYNAMIC_COPY); 1524 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 1525 1526 /* Mapping with new named buffer map function. */ 1527 glw::GLuint* data = (glw::GLuint*)m_pMapNamedBuffer(buffer, GL_WRITE_ONLY); 1528 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 1529 1530 if (DE_NULL == data) 1531 { 1532 /* Log. */ 1533 m_context.getTestContext().getLog() 1534 << tcu::TestLog::Message << "glMapNamedBuffer returned NULL pointer, but buffer's data was expected." 1535 << tcu::TestLog::EndMessage; 1536 } 1537 else 1538 { 1539 /* Reference data upload. */ 1540 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 1541 { 1542 data[i] = s_reference[i]; 1543 } 1544 1545 /* Unmapping with new named buffer unmap function. */ 1546 if (GL_TRUE != m_pUnmapNamedBuffer(buffer)) 1547 { 1548 is_ok = false; 1549 1550 /* Log. */ 1551 m_context.getTestContext().getLog() 1552 << tcu::TestLog::Message 1553 << "glUnmapNamedBuffer called on mapped buffer has returned GL_FALSE, but GL_TRUE was expected." 1554 << tcu::TestLog::EndMessage; 1555 } 1556 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1557 1558 /* Mapping data, the old way. */ 1559 gl.bindBuffer(GL_ARRAY_BUFFER, buffer); 1560 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer failed."); 1561 1562 data = DE_NULL; 1563 1564 data = (glw::GLuint*)gl.mapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY); 1565 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer failed."); 1566 1567 /* Comparison results with reference data. */ 1568 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 1569 { 1570 is_ok &= (data[i] == s_reference[i]); 1571 } 1572 1573 if (!is_ok) 1574 { 1575 /* Log. */ 1576 m_context.getTestContext().getLog() 1577 << tcu::TestLog::Message 1578 << "glMapNamedBuffer, called with GL_WRITE_ONLY access flag, had not stored the reference data." 1579 << tcu::TestLog::EndMessage; 1580 } 1581 1582 gl.unmapBuffer(GL_ARRAY_BUFFER); 1583 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer failed."); 1584 } 1585 } 1586 catch (...) 1587 { 1588 is_ok = false; 1589 is_error = true; 1590 } 1591 1592 /* Clean up. */ 1593 if (buffer) 1594 { 1595 gl.deleteBuffers(1, &buffer); 1596 1597 buffer = false; 1598 } 1599 1600 /* Errors clean up. */ 1601 while (gl.getError()) 1602 ; 1603 1604 /* Result's setup. */ 1605 if (is_ok) 1606 { 1607 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1608 } 1609 else 1610 { 1611 if (is_error) 1612 { 1613 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 1614 } 1615 else 1616 { 1617 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1618 } 1619 } 1620 1621 return STOP; 1622 } 1623 1624 const glw::GLuint MapWriteOnlyTest::s_reference[] = { 1625 0, 1, 2, 4, 8, 16, 64, 128, 256, 512, 1024, 2048, 4096 1626 }; //!< Reference data. 1627 const glw::GLsizei MapWriteOnlyTest::s_reference_size = sizeof(s_reference); //!< Reference data size. 1628 const glw::GLsizei MapWriteOnlyTest::s_reference_count = 1629 s_reference_size / sizeof(s_reference[0]); //!< Reference data elements' count. 1630 1631 /******************************** Buffers Range Map Read Bit Test Implementation ********************************/ 1632 1633 /** @brief Buffers Range Map Read Bit Test constructor. 1634 * 1635 * @param [in] context OpenGL context. 1636 */ 1637 MapRangeReadBitTest::MapRangeReadBitTest(deqp::Context& context) 1638 : deqp::TestCase(context, "buffers_map_range_read_bit", "Buffer Objects Map Range Read Bit Test") 1639 , m_pNamedBufferStorage(DE_NULL) 1640 , m_pMapNamedBufferRange(DE_NULL) 1641 , m_pUnmapNamedBuffer(DE_NULL) 1642 { 1643 /* Intentionally left blank. */ 1644 } 1645 1646 /** @brief Iterate Buffers Range Map Read Bit Test cases. 1647 * 1648 * @return Iteration result. 1649 */ 1650 tcu::TestNode::IterateResult MapRangeReadBitTest::iterate() 1651 { 1652 /* Shortcut for GL functionality. */ 1653 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1654 1655 /* Get context setup. */ 1656 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 1657 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 1658 1659 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 1660 { 1661 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 1662 1663 return STOP; 1664 } 1665 1666 /* Running tests. */ 1667 bool is_ok = true; 1668 bool is_error = false; 1669 1670 glw::GLuint buffer = 0; 1671 1672 m_pNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGE)gl.namedBufferStorage; 1673 m_pMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGE)gl.mapNamedBufferRange; 1674 m_pUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFER)gl.unmapNamedBuffer; 1675 1676 try 1677 { 1678 if ((DE_NULL == m_pNamedBufferStorage) || (DE_NULL == m_pMapNamedBufferRange) || 1679 (DE_NULL == m_pUnmapNamedBuffer)) 1680 { 1681 throw 0; 1682 } 1683 1684 glw::GLbitfield access_flags[] = { GL_MAP_READ_BIT, GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT, 1685 GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT }; 1686 1687 glw::GLuint access_flags_count = sizeof(access_flags) / sizeof(access_flags[0]); 1688 1689 for (glw::GLuint i = 0; i < access_flags_count; ++i) 1690 { 1691 /* Buffer creation. */ 1692 gl.createBuffers(1, &buffer); 1693 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 1694 1695 /* Buffer's storage allocation and reference data upload. */ 1696 m_pNamedBufferStorage(buffer, s_reference_size, s_reference, access_flags[i]); 1697 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 1698 1699 /* Mapping with first half of named buffer. */ 1700 glw::GLuint* data = (glw::GLuint*)m_pMapNamedBufferRange(buffer, 0, s_reference_size / 2, access_flags[i]); 1701 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBufferRange failed."); 1702 1703 /* Check with reference. */ 1704 is_ok &= CompareWithReference(data, 0, s_reference_size / 2); 1705 1706 /* Unmapping with new named buffer unmap function. */ 1707 m_pUnmapNamedBuffer(buffer); 1708 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1709 1710 /* Mapping with second half of named buffer. */ 1711 data = (glw::GLuint*)m_pMapNamedBufferRange(buffer, s_reference_size / 2, s_reference_size / 2, 1712 access_flags[i]); 1713 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBufferRange failed."); 1714 1715 /* Check with reference. */ 1716 is_ok &= CompareWithReference(data, s_reference_size / 2, s_reference_size / 2); 1717 1718 /* Unmapping with new named buffer unmap function. */ 1719 m_pUnmapNamedBuffer(buffer); 1720 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1721 1722 /* Clean up. */ 1723 if (buffer) 1724 { 1725 gl.deleteBuffers(1, &buffer); 1726 1727 buffer = 0; 1728 } 1729 } 1730 } 1731 catch (...) 1732 { 1733 is_ok = false; 1734 is_error = true; 1735 } 1736 1737 /* Clean up. */ 1738 if (buffer) 1739 { 1740 gl.deleteBuffers(1, &buffer); 1741 1742 buffer = 0; 1743 } 1744 1745 /* Errors clean up. */ 1746 while (gl.getError()) 1747 ; 1748 1749 /* Result's setup. */ 1750 if (is_ok) 1751 { 1752 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1753 } 1754 else 1755 { 1756 if (is_error) 1757 { 1758 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 1759 } 1760 else 1761 { 1762 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 1763 } 1764 } 1765 1766 return STOP; 1767 } 1768 1769 /** @brief Compare array of unsigned integers with subrange of reference values (s_reference). 1770 * 1771 * @param [in] data Data to be compared. 1772 * @param [in] offset Offset in the reference data. 1773 * @param [in] length Length of the data to be compared. 1774 * 1775 * @return True if comparison succeeded, false otherwise. 1776 */ 1777 bool MapRangeReadBitTest::CompareWithReference(glw::GLuint* data, glw::GLintptr offset, glw::GLsizei length) 1778 { 1779 if (DE_NULL == data) 1780 { 1781 /* Log. */ 1782 m_context.getTestContext().getLog() 1783 << tcu::TestLog::Message << "glMapNamedBufferRange called with offset " << offset << " and length " 1784 << length << " returned NULL pointer, but buffer's data was expected." << tcu::TestLog::EndMessage; 1785 } 1786 else 1787 { 1788 glw::GLuint start = static_cast<glw::GLuint>((offset) / sizeof(s_reference[0])); 1789 glw::GLuint end = static_cast<glw::GLuint>((offset + length) / sizeof(s_reference[0])); 1790 1791 /* Comparison results with reference data. */ 1792 for (glw::GLuint i = start; i < end; ++i) 1793 { 1794 #if (DE_COMPILER == DE_COMPILER_GCC) 1795 #pragma GCC diagnostic push 1796 #pragma GCC diagnostic ignored "-Warray-bounds" 1797 #endif 1798 if (data[i - start] != s_reference[i]) 1799 { 1800 /* Log. */ 1801 m_context.getTestContext().getLog() 1802 << tcu::TestLog::Message << "glMapNamedBufferRange called with offset " << offset << " and length " 1803 << length << " returned pointer to data which is not identical to reference data." 1804 << tcu::TestLog::EndMessage; 1805 1806 return false; 1807 } 1808 #if (DE_COMPILER == DE_COMPILER_GCC) 1809 #pragma GCC diagnostic pop 1810 #endif 1811 } 1812 } 1813 1814 return true; 1815 } 1816 1817 const glw::GLuint MapRangeReadBitTest::s_reference[] = { 1818 1, 2, 4, 8, 16, 64, 128, 256, 512, 1024, 2048, 4096 1819 }; //!< Reference data. 1820 const glw::GLsizei MapRangeReadBitTest::s_reference_size = sizeof(s_reference); //!< Reference data size. 1821 const glw::GLsizei MapRangeReadBitTest::s_reference_count = 1822 s_reference_size / sizeof(s_reference[0]); //!< Reference data elements' count. 1823 1824 /******************************** Buffers Range Map Write Bit Test Implementation ********************************/ 1825 1826 /** @brief Buffers Range Map Write Bit Test constructor. 1827 * 1828 * @param [in] context OpenGL context. 1829 */ 1830 MapRangeWriteBitTest::MapRangeWriteBitTest(deqp::Context& context) 1831 : deqp::TestCase(context, "buffers_map_range_write_bit", "Buffer Objects Map Range Write Bit Test") 1832 , m_pNamedBufferStorage(DE_NULL) 1833 , m_pMapNamedBufferRange(DE_NULL) 1834 , m_pUnmapNamedBuffer(DE_NULL) 1835 , m_pFlushMappedNamedBufferRange(DE_NULL) 1836 { 1837 /* Intentionally left blank. */ 1838 } 1839 1840 /** @brief Iterate Buffers Range Map Read Bit Test cases. 1841 * 1842 * @return Iteration result. 1843 */ 1844 tcu::TestNode::IterateResult MapRangeWriteBitTest::iterate() 1845 { 1846 /* Shortcut for GL functionality. */ 1847 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 1848 1849 /* Get context setup. */ 1850 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 1851 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 1852 1853 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 1854 { 1855 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 1856 1857 return STOP; 1858 } 1859 1860 /* Running tests. */ 1861 bool is_ok = true; 1862 bool is_error = false; 1863 1864 glw::GLuint buffer = 0; 1865 1866 m_pNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGE)gl.namedBufferStorage; 1867 m_pMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGE)gl.mapNamedBufferRange; 1868 m_pUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFER)gl.unmapNamedBuffer; 1869 m_pFlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE)gl.flushMappedNamedBufferRange; 1870 1871 try 1872 { 1873 if ((DE_NULL == m_pNamedBufferStorage) || (DE_NULL == m_pMapNamedBufferRange) || 1874 (DE_NULL == m_pUnmapNamedBuffer) || (DE_NULL == m_pFlushMappedNamedBufferRange)) 1875 { 1876 throw 0; 1877 } 1878 1879 struct 1880 { 1881 glw::GLbitfield creation; 1882 glw::GLbitfield first_mapping; 1883 glw::GLbitfield second_mapping; 1884 } access_flags[] = { 1885 { GL_MAP_WRITE_BIT | GL_MAP_READ_BIT, GL_MAP_WRITE_BIT, GL_MAP_WRITE_BIT }, 1886 { GL_MAP_WRITE_BIT | GL_MAP_READ_BIT, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT, 1887 GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT }, 1888 { GL_MAP_WRITE_BIT | GL_MAP_READ_BIT, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, GL_MAP_WRITE_BIT }, 1889 { GL_MAP_WRITE_BIT | GL_MAP_READ_BIT, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT, 1890 GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT }, 1891 { GL_MAP_WRITE_BIT | GL_MAP_READ_BIT, GL_MAP_WRITE_BIT, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT } 1892 }; 1893 1894 glw::GLuint access_flags_count = sizeof(access_flags) / sizeof(access_flags[0]); 1895 1896 for (glw::GLuint i = 0; i < access_flags_count; ++i) 1897 { 1898 /* Buffer creation. */ 1899 gl.createBuffers(1, &buffer); 1900 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 1901 1902 /* Buffer's storage allocation and reference data upload. */ 1903 m_pNamedBufferStorage(buffer, s_reference_size, DE_NULL, access_flags[i].creation); 1904 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferStorage failed."); 1905 1906 /* Mapping with first half of named buffer. */ 1907 glw::GLuint* data = 1908 (glw::GLuint*)m_pMapNamedBufferRange(buffer, 0, s_reference_size / 2, access_flags[i].first_mapping); 1909 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBufferRange failed."); 1910 1911 /* Write to mapped buffer. */ 1912 for (glw::GLsizei j = 0; j < s_reference_count / 2; ++j) 1913 { 1914 data[j] = s_reference[j]; 1915 } 1916 1917 /* Flush, if needed. */ 1918 glw::GLenum flush_error = GL_NO_ERROR; 1919 1920 if (GL_MAP_FLUSH_EXPLICIT_BIT & access_flags[i].first_mapping) 1921 { 1922 m_pFlushMappedNamedBufferRange(buffer, 0, s_reference_size / 2); 1923 1924 flush_error = gl.getError(); 1925 } 1926 1927 /* Unmapping with new named buffer unmap function. */ 1928 m_pUnmapNamedBuffer(buffer); 1929 GLU_EXPECT_NO_ERROR(flush_error, "glFlushMappedNamedBufferRange failed."); 1930 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1931 1932 /* Mapping with second half of named buffer. */ 1933 data = (glw::GLuint*)m_pMapNamedBufferRange(buffer, s_reference_size / 2, s_reference_size / 2, 1934 access_flags[i].second_mapping); 1935 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBufferRange failed."); 1936 1937 /* Write to mapped buffer. */ 1938 for (glw::GLsizei j = 0; j < s_reference_count / 2; ++j) 1939 { 1940 data[j] = s_reference[j + s_reference_count / 2]; 1941 } 1942 1943 /* Flush, if needed. */ 1944 flush_error = GL_NO_ERROR; 1945 1946 if (GL_MAP_FLUSH_EXPLICIT_BIT & access_flags[i].second_mapping) 1947 { 1948 m_pFlushMappedNamedBufferRange(buffer, 0, s_reference_size / 2); 1949 1950 flush_error = gl.getError(); 1951 } 1952 1953 /* Unmapping with new named buffer unmap function. */ 1954 m_pUnmapNamedBuffer(buffer); 1955 GLU_EXPECT_NO_ERROR(flush_error, "glFlushMappedNamedBufferRange failed."); 1956 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 1957 1958 /* Check that previous mappings correctly filled buffer with reference data. */ 1959 is_ok &= CompareWithReference(buffer, access_flags[i].first_mapping | access_flags[i].second_mapping); 1960 1961 /* Clean up. */ 1962 if (buffer) 1963 { 1964 gl.deleteBuffers(1, &buffer); 1965 1966 buffer = 0; 1967 } 1968 } 1969 } 1970 catch (...) 1971 { 1972 is_ok = false; 1973 is_error = true; 1974 } 1975 1976 /* Clean up. */ 1977 if (buffer) 1978 { 1979 gl.deleteBuffers(1, &buffer); 1980 1981 buffer = 0; 1982 } 1983 1984 /* Errors clean up. */ 1985 while (gl.getError()) 1986 ; 1987 1988 /* Result's setup. */ 1989 if (is_ok) 1990 { 1991 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1992 } 1993 else 1994 { 1995 if (is_error) 1996 { 1997 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 1998 } 1999 else 2000 { 2001 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2002 } 2003 } 2004 2005 return STOP; 2006 } 2007 2008 /** @brief Compare buffer's content with the reference values (s_reference) and log possible failure. 2009 * 2010 * @param [in] buffer Buffer to be tested. 2011 * @param [in] access_flag Access flag used during test's mapping (for failure logging purposes). 2012 * 2013 * @return True if comparison succeeded, false otherwise. 2014 */ 2015 bool MapRangeWriteBitTest::CompareWithReference(glw::GLuint buffer, glw::GLbitfield access_flag) 2016 { 2017 /* Shortcut for GL functionality. */ 2018 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2019 2020 /* Map buffer with legacy API. */ 2021 gl.bindBuffer(GL_ARRAY_BUFFER, buffer); 2022 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer failed."); 2023 2024 glw::GLuint* data = (glw::GLuint*)gl.mapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY); 2025 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer failed."); 2026 2027 /* Default return value. */ 2028 bool is_ok = true; 2029 2030 if (DE_NULL != data) 2031 { 2032 /* Comparison results with reference data. */ 2033 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 2034 { 2035 if (data[i] != s_reference[i]) 2036 { 2037 std::string access_string = "GL_MAP_WRITE_BIT"; 2038 2039 if (GL_MAP_INVALIDATE_RANGE_BIT & access_flag) 2040 { 2041 access_string = "(GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT)"; 2042 } 2043 2044 if (GL_MAP_INVALIDATE_BUFFER_BIT & access_flag) 2045 { 2046 access_string = "(GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)"; 2047 } 2048 2049 if (GL_MAP_FLUSH_EXPLICIT_BIT & access_flag) 2050 { 2051 access_string = "(GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT)"; 2052 } 2053 2054 if (GL_MAP_UNSYNCHRONIZED_BIT & access_flag) 2055 { 2056 access_string = "(GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT)"; 2057 } 2058 2059 /* Log. */ 2060 m_context.getTestContext().getLog() 2061 << tcu::TestLog::Message << "Test of glMapNamedBufferRange with access flag " << access_string 2062 << " failed to fill the buffer with reference data." << tcu::TestLog::EndMessage; 2063 2064 is_ok = false; 2065 2066 break; 2067 } 2068 } 2069 } 2070 2071 /* Unmap buffer. */ 2072 gl.unmapBuffer(GL_ARRAY_BUFFER); 2073 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer failed."); 2074 2075 return is_ok; 2076 } 2077 2078 const glw::GLuint MapRangeWriteBitTest::s_reference[] = { 2079 1, 2, 4, 8, 16, 64, 128, 256, 512, 1024, 2048, 4096 2080 }; //!< Reference data. 2081 const glw::GLsizei MapRangeWriteBitTest::s_reference_size = sizeof(s_reference); //!< Reference data size. 2082 const glw::GLsizei MapRangeWriteBitTest::s_reference_count = 2083 s_reference_size / sizeof(s_reference[0]); //!< Reference data elements' count. 2084 2085 /******************************** Get Named Buffer SubData Query Test Implementation ********************************/ 2086 2087 /** @brief Get Named Buffer SubData Query Test's static constants. */ 2088 const glw::GLuint SubDataQueryTest::s_reference[] = { 2089 1, 2, 4, 8, 16, 64, 128, 256, 512, 1024, 2048, 4096 2090 }; //!< Reference data. 2091 const glw::GLsizei SubDataQueryTest::s_reference_size = sizeof(s_reference); //!< Reference data size. 2092 const glw::GLsizei SubDataQueryTest::s_reference_count = 2093 s_reference_size / sizeof(s_reference[0]); //!< Reference data elements' count. 2094 2095 /** @brief Get Named Buffer SubData Query Test constructor. 2096 * 2097 * @param [in] context OpenGL context. 2098 */ 2099 SubDataQueryTest::SubDataQueryTest(deqp::Context& context) 2100 : deqp::TestCase(context, "buffers_get_named_buffer_subdata", "Buffer Objects Get Named Buffer SubData Query Test") 2101 , m_pNamedBufferData(DE_NULL) 2102 , m_pGetNamedBufferSubData(DE_NULL) 2103 { 2104 /* Intentionally left blank. */ 2105 } 2106 2107 /** @brief Iterate Get Named Buffer SubData Query Test cases. 2108 * 2109 * @return Iteration result. 2110 */ 2111 tcu::TestNode::IterateResult SubDataQueryTest::iterate() 2112 { 2113 /* Shortcut for GL functionality. */ 2114 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2115 2116 /* Get context setup. */ 2117 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 2118 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 2119 2120 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 2121 { 2122 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 2123 2124 return STOP; 2125 } 2126 2127 /* Running tests. */ 2128 bool is_ok = true; 2129 bool is_error = false; 2130 2131 glw::GLuint buffer = 0; 2132 2133 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 2134 m_pGetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATA)gl.getNamedBufferSubData; 2135 2136 try 2137 { 2138 if ((DE_NULL == m_pNamedBufferData) || (DE_NULL == m_pGetNamedBufferSubData)) 2139 { 2140 throw 0; 2141 } 2142 2143 /* Buffer creation. */ 2144 gl.createBuffers(1, &buffer); 2145 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 2146 2147 /* Buffer's storage allocation and reference data upload. */ 2148 m_pNamedBufferData(buffer, s_reference_size, s_reference, GL_DYNAMIC_COPY); 2149 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData failed."); 2150 2151 /* Mapping with new named buffer map function. */ 2152 glw::GLuint data[s_reference_count] = {}; 2153 m_pGetNamedBufferSubData(buffer, 0, s_reference_size / 2, data); 2154 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetNamedBufferSubData failed."); 2155 2156 m_pGetNamedBufferSubData(buffer, s_reference_size / 2, s_reference_size / 2, &data[s_reference_count / 2]); 2157 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetNamedBufferSubData failed."); 2158 2159 /* Comparison results with reference data. */ 2160 for (glw::GLsizei i = 0; i < s_reference_count; ++i) 2161 { 2162 is_ok &= (data[i] == s_reference[i]); 2163 } 2164 2165 if (!is_ok) 2166 { 2167 /* Log. */ 2168 m_context.getTestContext().getLog() 2169 << tcu::TestLog::Message 2170 << "glGetNamedBufferSubData returned data which is not identical to reference data." 2171 << tcu::TestLog::EndMessage; 2172 } 2173 } 2174 catch (...) 2175 { 2176 is_ok = false; 2177 is_error = true; 2178 } 2179 2180 /* Clean up. */ 2181 if (buffer) 2182 { 2183 gl.deleteBuffers(1, &buffer); 2184 2185 buffer = false; 2186 } 2187 2188 /* Errors clean up. */ 2189 while (gl.getError()) 2190 ; 2191 2192 /* Result's setup. */ 2193 if (is_ok) 2194 { 2195 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2196 } 2197 else 2198 { 2199 if (is_error) 2200 { 2201 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 2202 } 2203 else 2204 { 2205 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2206 } 2207 } 2208 2209 return STOP; 2210 } 2211 2212 /******************************** Defaults Test Implementation ********************************/ 2213 2214 /** @brief Defaults Query Test constructor. 2215 * 2216 * @param [in] context OpenGL context. 2217 */ 2218 DefaultsTest::DefaultsTest(deqp::Context& context) 2219 : deqp::TestCase(context, "buffers_defaults", "Buffer Objects Defaults Test") 2220 , m_pNamedBufferData(DE_NULL) 2221 , m_pGetNamedBufferParameteri64v(DE_NULL) 2222 , m_pGetNamedBufferParameteriv(DE_NULL) 2223 , m_pGetNamedBufferPointerv(DE_NULL) 2224 { 2225 /* Intentionally left blank. */ 2226 } 2227 2228 /** @brief Compare value with the reference. 2229 * 2230 * @param [in] value Value to be compared. 2231 * @param [in] reference_value Reference value for comparison. 2232 * @param [in] pname_string String of parameter name of the value (for logging). 2233 * @param [in] function_string String of function which returned the value (for logging). 2234 * 2235 * @return True if value is equal to reference value, false otherwise. False solution is logged. 2236 */ 2237 template <typename T> 2238 bool DefaultsTest::CheckValue(const T value, const T reference_value, const glw::GLchar* pname_string, 2239 const glw::GLchar* function_string) 2240 { 2241 if (reference_value != value) 2242 { 2243 /* Log. */ 2244 m_context.getTestContext().getLog() << tcu::TestLog::Message << function_string << " called with " 2245 << pname_string << " parameter name returned " << value << ", but " 2246 << reference_value << " was expected." << tcu::TestLog::EndMessage; 2247 2248 return false; 2249 } 2250 return true; 2251 } 2252 2253 /** @brief Iterate Defaults Test cases. 2254 * 2255 * @return Iteration result. 2256 */ 2257 tcu::TestNode::IterateResult DefaultsTest::iterate() 2258 { 2259 /* Shortcut for GL functionality. */ 2260 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2261 2262 /* Get context setup. */ 2263 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 2264 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 2265 2266 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 2267 { 2268 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 2269 2270 return STOP; 2271 } 2272 2273 /* Running tests. */ 2274 bool is_ok = true; 2275 bool is_error = false; 2276 2277 glw::GLuint buffer = 0; 2278 2279 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 2280 m_pGetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64V)gl.getNamedBufferParameteri64v; 2281 m_pGetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIV)gl.getNamedBufferParameteriv; 2282 m_pGetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERV)gl.getNamedBufferPointerv; 2283 2284 try 2285 { 2286 if ((DE_NULL == m_pNamedBufferData) || (DE_NULL == m_pGetNamedBufferParameteri64v) || 2287 (DE_NULL == m_pGetNamedBufferParameteriv) || (DE_NULL == m_pGetNamedBufferPointerv)) 2288 { 2289 throw 0; 2290 } 2291 2292 /* Buffer creation. */ 2293 gl.createBuffers(1, &buffer); 2294 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 2295 2296 /* Test data for glGetNamedBufferParameteri*v. */ 2297 static const struct 2298 { 2299 glw::GLenum pname; 2300 const glw::GLchar* pname_string; 2301 glw::GLint expected_data; 2302 } test_values[] = { { GL_BUFFER_SIZE, "GL_BUFFER_SIZE", 0 }, 2303 { GL_BUFFER_USAGE, "GL_BUFFER_USAGE", GL_STATIC_DRAW }, 2304 { GL_BUFFER_ACCESS, "GL_BUFFER_ACCESS", GL_READ_WRITE }, 2305 { GL_BUFFER_ACCESS_FLAGS, "GL_BUFFER_ACCESS_FLAGS", 0 }, 2306 { GL_BUFFER_IMMUTABLE_STORAGE, "GL_BUFFER_IMMUTABLE_STORAGE", GL_FALSE }, 2307 { GL_BUFFER_MAPPED, "GL_BUFFER_MAPPED", GL_FALSE }, 2308 { GL_BUFFER_MAP_OFFSET, "GL_BUFFER_MAP_OFFSET", 0 }, 2309 { GL_BUFFER_MAP_LENGTH, "GL_BUFFER_MAP_LENGTH", 0 }, 2310 { GL_BUFFER_STORAGE_FLAGS, "GL_BUFFER_STORAGE_FLAGS", 0 } }; 2311 2312 static const glw::GLuint test_dictionary_count = sizeof(test_values) / sizeof(test_values[0]); 2313 2314 /* Test glGetNamedBufferParameteriv. */ 2315 for (glw::GLuint i = 0; i < test_dictionary_count; ++i) 2316 { 2317 glw::GLint data = -1; 2318 2319 m_pGetNamedBufferParameteriv(buffer, test_values[i].pname, &data); 2320 2321 is_ok &= CheckParameterError(test_values[i].pname_string, "glGetNamedBufferParameteriv"); 2322 2323 is_ok &= CheckValue<glw::GLint>(data, test_values[i].expected_data, test_values[i].pname_string, 2324 "glGetNamedBufferParameteriv"); 2325 } 2326 2327 /* Test glGetNamedBufferParameteri64v. */ 2328 for (glw::GLuint i = 0; i < test_dictionary_count; ++i) 2329 { 2330 glw::GLint64 data = -1; 2331 2332 m_pGetNamedBufferParameteri64v(buffer, test_values[i].pname, &data); 2333 2334 is_ok &= CheckParameterError(test_values[i].pname_string, "glGetNamedBufferParameteri64v"); 2335 2336 is_ok &= CheckValue<glw::GLint64>(data, (glw::GLint64)test_values[i].expected_data, 2337 test_values[i].pname_string, "glGetNamedBufferParameteri64v"); 2338 } 2339 2340 /* Test glGetNamedBufferPointerv. */ 2341 { 2342 glw::GLvoid* data = (glw::GLvoid*)1; 2343 2344 m_pGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &data); 2345 2346 is_ok &= CheckParameterError("GL_BUFFER_MAP_POINTER", "glGetNamedBufferPointer"); 2347 2348 is_ok &= CheckValue<glw::GLvoid*>(data, (glw::GLvoid*)DE_NULL, "GL_BUFFER_MAP_POINTER", 2349 "glGetNamedBufferParameteriv"); 2350 } 2351 } 2352 catch (...) 2353 { 2354 is_ok = false; 2355 is_error = true; 2356 } 2357 2358 /* Clean up. */ 2359 if (buffer) 2360 { 2361 gl.deleteBuffers(1, &buffer); 2362 2363 buffer = 0; 2364 } 2365 2366 /* Errors clean up. */ 2367 while (gl.getError()) 2368 ; 2369 2370 /* Result's setup. */ 2371 if (is_ok) 2372 { 2373 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2374 } 2375 else 2376 { 2377 if (is_error) 2378 { 2379 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 2380 } 2381 else 2382 { 2383 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2384 } 2385 } 2386 2387 return STOP; 2388 } 2389 2390 /** @brief Check for GL error and log. 2391 * 2392 * @param [in] pname_string String of parameter name of the value (for logging). 2393 * @param [in] function_string String of function which returned the value (for logging). 2394 * 2395 * @return True if error was generated, false otherwise. False solution is logged. 2396 */ 2397 bool DefaultsTest::CheckParameterError(const glw::GLchar* pname_string, const glw::GLchar* function_string) 2398 { 2399 /* Shortcut for GL functionality. */ 2400 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2401 2402 /* Error check. */ 2403 if (glw::GLenum error = gl.getError()) 2404 { 2405 /* Log. */ 2406 m_context.getTestContext().getLog() << tcu::TestLog::Message << function_string << " called with " 2407 << pname_string << " parameter name unexpectedly returned " 2408 << glu::getErrorStr(error) << "error." << tcu::TestLog::EndMessage; 2409 2410 return false; 2411 } 2412 2413 return true; 2414 } 2415 2416 /******************************** Errors Test Implementation ********************************/ 2417 2418 /** @brief Errors Query Test constructor. 2419 * 2420 * @param [in] context OpenGL context. 2421 */ 2422 ErrorsTest::ErrorsTest(deqp::Context& context) 2423 : deqp::TestCase(context, "buffers_errors", "Buffer Objects Errors Test") 2424 , m_pClearNamedBufferData(DE_NULL) 2425 , m_pClearNamedBufferSubData(DE_NULL) 2426 , m_pCopyNamedBufferSubData(DE_NULL) 2427 , m_pFlushMappedNamedBufferRange(DE_NULL) 2428 , m_pGetNamedBufferParameteri64v(DE_NULL) 2429 , m_pGetNamedBufferParameteriv(DE_NULL) 2430 , m_pGetNamedBufferPointerv(DE_NULL) 2431 , m_pGetNamedBufferSubData(DE_NULL) 2432 , m_pMapNamedBuffer(DE_NULL) 2433 , m_pMapNamedBufferRange(DE_NULL) 2434 , m_pNamedBufferData(DE_NULL) 2435 , m_pNamedBufferStorage(DE_NULL) 2436 , m_pNamedBufferSubData(DE_NULL) 2437 , m_pUnmapNamedBuffer(DE_NULL) 2438 { 2439 /* Intentionally left blank. */ 2440 } 2441 2442 /** @brief Iterate Errors Test cases. 2443 * 2444 * @return Iteration result. 2445 */ 2446 tcu::TestNode::IterateResult ErrorsTest::iterate() 2447 { 2448 /* Shortcut for GL functionality. */ 2449 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2450 2451 /* Get context setup. */ 2452 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 2453 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 2454 2455 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 2456 { 2457 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 2458 2459 return STOP; 2460 } 2461 2462 /* Running tests. */ 2463 bool is_ok = true; 2464 bool is_error = false; 2465 2466 /* API function pointers setup. */ 2467 m_pClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATA)gl.clearNamedBufferData; 2468 m_pClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATA)gl.clearNamedBufferSubData; 2469 m_pCopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATA)gl.copyNamedBufferSubData; 2470 m_pFlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE)gl.flushMappedNamedBufferRange; 2471 m_pGetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64V)gl.getNamedBufferParameteri64v; 2472 m_pGetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIV)gl.getNamedBufferParameteriv; 2473 m_pGetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERV)gl.getNamedBufferPointerv; 2474 m_pGetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATA)gl.getNamedBufferSubData; 2475 m_pMapNamedBuffer = (PFNGLMAPNAMEDBUFFER)gl.mapNamedBuffer; 2476 m_pMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGE)gl.mapNamedBufferRange; 2477 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 2478 m_pNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGE)gl.namedBufferStorage; 2479 m_pNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATA)gl.namedBufferSubData; 2480 m_pUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFER)gl.unmapNamedBuffer; 2481 2482 try 2483 { 2484 /* API function pointers check. */ 2485 if ((DE_NULL == m_pClearNamedBufferData) || (DE_NULL == m_pClearNamedBufferSubData) || 2486 (DE_NULL == m_pCopyNamedBufferSubData) || (DE_NULL == m_pFlushMappedNamedBufferRange) || 2487 (DE_NULL == m_pGetNamedBufferParameteri64v) || (DE_NULL == m_pGetNamedBufferParameteriv) || 2488 (DE_NULL == m_pGetNamedBufferPointerv) || (DE_NULL == m_pGetNamedBufferSubData) || 2489 (DE_NULL == m_pMapNamedBuffer) || (DE_NULL == m_pMapNamedBufferRange) || (DE_NULL == m_pNamedBufferData) || 2490 (DE_NULL == m_pNamedBufferStorage) || (DE_NULL == m_pNamedBufferSubData) || 2491 (DE_NULL == m_pUnmapNamedBuffer)) 2492 { 2493 throw 0; 2494 } 2495 2496 /* Running test cases. Cleaning errors. */ 2497 is_ok &= TestErrorsOfClearNamedBufferData(); 2498 while (gl.getError()) 2499 ; 2500 is_ok &= TestErrorsOfClearNamedBufferSubData(); 2501 while (gl.getError()) 2502 ; 2503 is_ok &= TestErrorsOfCopyNamedBufferSubData(); 2504 while (gl.getError()) 2505 ; 2506 is_ok &= TestErrorsOfCreateBuffers(); 2507 while (gl.getError()) 2508 ; 2509 is_ok &= TestErrorsOfFlushMappedNamedBufferRange(); 2510 while (gl.getError()) 2511 ; 2512 is_ok &= TestErrorsOfGetNamedBufferParameter(); 2513 while (gl.getError()) 2514 ; 2515 is_ok &= TestErrorsOfGetNamedBufferPointerv(); 2516 while (gl.getError()) 2517 ; 2518 is_ok &= TestErrorsOfGetNamedBufferSubData(); 2519 while (gl.getError()) 2520 ; 2521 is_ok &= TestErrorsOfMapNamedBuffer(); 2522 while (gl.getError()) 2523 ; 2524 is_ok &= TestErrorsOfMapNamedBufferRange(); 2525 while (gl.getError()) 2526 ; 2527 is_ok &= TestErrorsOfNamedBufferData(); 2528 while (gl.getError()) 2529 ; 2530 is_ok &= TestErrorsOfNamedBufferStorage(); 2531 while (gl.getError()) 2532 ; 2533 is_ok &= TestErrorsOfNamedBufferSubData(); 2534 while (gl.getError()) 2535 ; 2536 is_ok &= TestErrorsOfUnmapNamedBuffer(); 2537 while (gl.getError()) 2538 ; 2539 } 2540 catch (...) 2541 { 2542 is_ok = false; 2543 is_error = true; 2544 } 2545 2546 /* Errors clean up. */ 2547 while (gl.getError()) 2548 ; 2549 2550 /* Result's setup. */ 2551 if (is_ok) 2552 { 2553 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 2554 } 2555 else 2556 { 2557 if (is_error) 2558 { 2559 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 2560 } 2561 else 2562 { 2563 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 2564 } 2565 } 2566 2567 return STOP; 2568 } 2569 2570 /** Check if error was generated and if it is equal to expected value. Log possible failure. 2571 * 2572 * @param [in] function_name Tested Function. 2573 * @param [in] expected_error Expected error function. 2574 * @param [in] when_shall_be_generated Description when shall the error occure. 2575 * 2576 * @return True if GL error is equal to the expected value, false otherwise. 2577 */ 2578 bool ErrorsTest::ErrorCheckAndLog(const glw::GLchar* function_name, const glw::GLenum expected_error, 2579 const glw::GLchar* when_shall_be_generated) 2580 { 2581 /* Shortcut for GL functionality. */ 2582 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2583 2584 /* Error value storage. */ 2585 glw::GLenum error = GL_NO_ERROR; 2586 2587 /* Error comparision. */ 2588 if (expected_error != (error = gl.getError())) 2589 { 2590 /* Log. */ 2591 m_context.getTestContext().getLog() << tcu::TestLog::Message << function_name << " does not generate " 2592 << glu::getErrorStr(expected_error) << when_shall_be_generated 2593 << "The error value of " << glu::getErrorStr(error) << " was observed." 2594 << tcu::TestLog::EndMessage; 2595 2596 /* Error cleanup. */ 2597 while (gl.getError()) 2598 ; 2599 2600 /* Check failed. */ 2601 return false; 2602 } 2603 2604 /* Error was equal to expected. */ 2605 return true; 2606 } 2607 2608 /** @brief Test Errors Of ClearNamedBufferData function. 2609 * 2610 * Check that INVALID_OPERATION is generated by ClearNamedBufferData if 2611 * buffer is not the name of an existing buffer object. 2612 * 2613 * Check that INVALID_ENUM is generated by ClearNamedBufferData if 2614 * internal format is not one of the valid sized internal formats listed in 2615 * the table above. 2616 * 2617 * Check that INVALID_OPERATION is generated by ClearNamedBufferData if 2618 * any part of the specified range of the buffer object is mapped with 2619 * MapBufferRange or MapBuffer, unless it was mapped with the 2620 * MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags. 2621 * 2622 * Check that INVALID_VALUE is generated by ClearNamedBufferData if 2623 * format is not a valid format, or type is not a valid type. 2624 * 2625 * True if test case succeeded, false otherwise. 2626 */ 2627 bool ErrorsTest::TestErrorsOfClearNamedBufferData() 2628 { 2629 /* Shortcut for GL functionality. */ 2630 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2631 2632 /* Return value. */ 2633 bool is_ok = true; 2634 bool internal_error = false; 2635 2636 /* Common variables. */ 2637 glw::GLuint buffer = 0; 2638 glw::GLbyte dummy_data = 0; 2639 2640 try 2641 { 2642 /* Common preparations. */ 2643 gl.createBuffers(1, &buffer); 2644 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 2645 2646 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, 2647 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 2648 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferStorage failed."); 2649 2650 /* Test invalid buffer name error behavior. */ 2651 { 2652 /* Prepare for invalid buffer name error behavior verification. */ 2653 glw::GLuint not_a_buffer_name = 0; 2654 2655 while (gl.isBuffer(++not_a_buffer_name)) 2656 ; 2657 2658 /* Test. */ 2659 m_pClearNamedBufferData(not_a_buffer_name, GL_R8, GL_RED, GL_UNSIGNED_BYTE, &dummy_data); 2660 2661 is_ok &= ErrorCheckAndLog("glClearNamedBufferData", GL_INVALID_OPERATION, 2662 " if buffer is not the name of an existing buffer object."); 2663 } 2664 2665 /* Test invalid sized internal format error behavior. */ 2666 { 2667 /* Prepare for invalid sized internal format error behavior verification. */ 2668 static const glw::GLenum valid_internal_formats[] = { 2669 GL_R8, GL_R16, GL_R16F, GL_R32F, GL_R8I, GL_R16I, GL_R32I, 2670 GL_R8UI, GL_R16UI, GL_R32UI, GL_RG8, GL_RG16, GL_RG16F, GL_RG32F, 2671 GL_RG8I, GL_RG16I, GL_RG32I, GL_RG8UI, GL_RG16UI, GL_RG32UI, GL_RGB32F, 2672 GL_RGB32I, GL_RGB32UI, GL_RGBA8, GL_RGBA16, GL_RGBA16F, GL_RGBA32F, GL_RGBA8I, 2673 GL_RGBA16I, GL_RGBA32I, GL_RGBA8UI, GL_RGBA16UI, GL_RGBA32UI, GL_NONE 2674 }; 2675 static const glw::GLenum valid_internal_formats_last = 2676 sizeof(valid_internal_formats) / sizeof(valid_internal_formats[0]) - 1; 2677 2678 glw::GLenum invalid_internal_format = 0; 2679 2680 while (&valid_internal_formats[valid_internal_formats_last] != 2681 std::find(&valid_internal_formats[0], &valid_internal_formats[valid_internal_formats_last], 2682 (++invalid_internal_format))) 2683 ; 2684 2685 /* Test. */ 2686 m_pClearNamedBufferData(buffer, invalid_internal_format, GL_RED, GL_UNSIGNED_BYTE, &dummy_data); 2687 2688 is_ok &= ErrorCheckAndLog("glClearNamedBufferData", GL_INVALID_ENUM, 2689 " if internal format is not one of the valid sized internal formats " 2690 "(GL_R8, GL_R16, GL_R16F, GL_R32F, GL_R8I, GL_R16I, GL_R32I, GL_R8UI," 2691 " GL_R16UI, GL_R32UI, GL_RG8, GL_RG16, GL_RG16F, GL_RG32F, GL_RG8I, GL_RG16I," 2692 " GL_RG32I, GL_RG8UI, GL_RG16UI, GL_RG32UI, GL_RGB32F, GL_RGB32I, GL_RGB32UI," 2693 " GL_RGBA8, GL_RGBA16, GL_RGBA16F, GL_RGBA32F, GL_RGBA8I, GL_RGBA16I, GL_RGBA32I," 2694 " GL_RGBA8UI, GL_RGBA16UI, GL_RGBA32UI)."); 2695 } 2696 2697 /* Test of mapped buffer clear error behavior verification (glMapNamedBuffer version). */ 2698 { 2699 (void)(glw::GLbyte*) m_pMapNamedBuffer(buffer, GL_READ_ONLY); 2700 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 2701 2702 m_pClearNamedBufferData(buffer, GL_R8, GL_RED, GL_UNSIGNED_BYTE, &dummy_data); 2703 2704 is_ok &= ErrorCheckAndLog("glClearNamedBufferData", GL_INVALID_OPERATION, 2705 " if any part of the specified range of the buffer" 2706 " object is mapped with MapBuffer, unless it was mapped with " 2707 "the MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags."); 2708 2709 m_pUnmapNamedBuffer(buffer); 2710 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 2711 } 2712 2713 /* Test of mapped buffer clear error behavior verification (glMapNamedBufferRange version). */ 2714 { 2715 (void)(glw::GLbyte*) m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 2716 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 2717 2718 m_pClearNamedBufferData(buffer, GL_R8, GL_RED, GL_UNSIGNED_BYTE, &dummy_data); 2719 2720 is_ok &= ErrorCheckAndLog("glClearNamedBufferData", GL_INVALID_OPERATION, 2721 " if any part of the specified range of the buffer" 2722 " object is mapped with MapBufferRange, unless it was mapped with " 2723 "the MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags."); 2724 2725 m_pUnmapNamedBuffer(buffer); 2726 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 2727 } 2728 2729 /* Test of persistently mapped buffer clear error with behavior verification (glMapNamedBufferRange version). */ 2730 { 2731 (void)(glw::GLbyte*) 2732 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT); 2733 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 2734 2735 m_pClearNamedBufferData(buffer, GL_R8, GL_RED, GL_UNSIGNED_BYTE, &dummy_data); 2736 2737 is_ok &= ErrorCheckAndLog("glClearNamedBufferData", GL_NO_ERROR, 2738 " if any part of the specified range of the buffer" 2739 " object is mapped with MapBuffer with the MAP_PERSISTENT_BIT" 2740 " bit set in the MapBufferRange access flags."); 2741 2742 m_pUnmapNamedBuffer(buffer); 2743 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 2744 } 2745 2746 /* Test invalid format error behavior. */ 2747 { 2748 /* Prepare for invalid format error behavior verification. */ 2749 static const glw::GLenum valid_formats[] = { GL_RED, GL_RG, 2750 GL_RGB, GL_BGR, 2751 GL_RGBA, GL_BGRA, 2752 GL_RED_INTEGER, GL_RG_INTEGER, 2753 GL_RGB_INTEGER, GL_BGR_INTEGER, 2754 GL_RGBA_INTEGER, GL_BGRA_INTEGER, 2755 GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, 2756 GL_DEPTH_STENCIL }; 2757 static const glw::GLenum valid_formats_last = sizeof(valid_formats) / sizeof(valid_formats[0]) - 1; 2758 2759 glw::GLenum invalid_format = 0; 2760 2761 while (&valid_formats[valid_formats_last] != 2762 std::find(&valid_formats[0], &valid_formats[valid_formats_last], (++invalid_format))) 2763 ; 2764 2765 /* Test. */ 2766 m_pClearNamedBufferData(buffer, GL_R8, invalid_format, GL_UNSIGNED_BYTE, &dummy_data); 2767 2768 is_ok &= ErrorCheckAndLog( 2769 "glClearNamedBufferData", GL_INVALID_ENUM, 2770 " if format is not a valid format " 2771 "(one of GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, " 2772 "GL_RED_INTEGER, GL_RG_INTEGER, GL_RGB_INTEGER, GL_BGR_INTEGER, GL_RGBA_INTEGER, GL_BGRA_INTEGER, " 2773 "GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL)."); 2774 } 2775 2776 /* Test invalid type error behavior. */ 2777 { 2778 /* Prepare for invalid type error behavior verification. */ 2779 static const glw::GLenum valid_types[] = { GL_RED, GL_RG, 2780 GL_RGB, GL_BGR, 2781 GL_RGBA, GL_BGRA, 2782 GL_RED_INTEGER, GL_RG_INTEGER, 2783 GL_RGB_INTEGER, GL_BGR_INTEGER, 2784 GL_RGBA_INTEGER, GL_BGRA_INTEGER, 2785 GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, 2786 GL_DEPTH_STENCIL }; 2787 static const glw::GLenum valid_types_last = sizeof(valid_types) / sizeof(valid_types[0]) - 1; 2788 2789 glw::GLenum invalid_type = 0; 2790 2791 while (&valid_types[valid_types_last] != 2792 std::find(&valid_types[0], &valid_types[valid_types_last], (++invalid_type))) 2793 ; 2794 2795 /* Test. */ 2796 m_pClearNamedBufferData(buffer, GL_R8, GL_RED, invalid_type, &dummy_data); 2797 2798 is_ok &= ErrorCheckAndLog( 2799 "glClearNamedBufferData", GL_INVALID_ENUM, 2800 " if format is not a valid type " 2801 "(one of GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, " 2802 "GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, " 2803 "GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, " 2804 "GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, " 2805 "GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, " 2806 "GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV)."); 2807 } 2808 } 2809 catch (...) 2810 { 2811 is_ok = false; 2812 internal_error = true; 2813 } 2814 2815 if (buffer) 2816 { 2817 gl.deleteBuffers(1, &buffer); 2818 2819 buffer = 0; 2820 } 2821 2822 if (internal_error) 2823 { 2824 throw 0; 2825 } 2826 2827 return is_ok; 2828 } 2829 2830 /** @brief Test Errors Of ClearNamedBufferSubData function. 2831 * 2832 * Check that INVALID_OPERATION is generated by ClearNamedBufferSubData 2833 * if buffer is not the name of an existing buffer object. 2834 * 2835 * Check that INVALID_ENUM is generated by ClearNamedBufferSubData if 2836 * internal format is not one of the valid sized internal formats listed in 2837 * the table above. 2838 * 2839 * Check that INVALID_VALUE is generated by ClearNamedBufferSubData if 2840 * offset or range are not multiples of the number of basic machine units 2841 * per-element for the internal format specified by internal format. This 2842 * value may be computed by multiplying the number of components for 2843 * internal format from the table by the size of the base type from the 2844 * specification table. 2845 * 2846 * Check that INVALID_VALUE is generated by ClearNamedBufferSubData if 2847 * offset or size is negative, or if offset+size is greater than the value 2848 * of BUFFER_SIZE for the buffer object. 2849 * 2850 * Check that INVALID_OPERATION is generated by ClearNamedBufferSubData 2851 * if any part of the specified range of the buffer object is mapped with 2852 * MapBufferRange or MapBuffer, unless it was mapped with the 2853 * MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags. 2854 * 2855 * Check that INVALID_VALUE is generated by ClearNamedBufferSubData if format is not 2856 * a valid format, or type is not a valid type. 2857 * 2858 * True if test case succeeded, false otherwise. 2859 */ 2860 bool ErrorsTest::TestErrorsOfClearNamedBufferSubData() 2861 { 2862 /* Shortcut for GL functionality. */ 2863 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 2864 2865 /* Return value. */ 2866 bool is_ok = true; 2867 bool internal_error = false; 2868 2869 /* Common variables. */ 2870 glw::GLuint buffer = 0; 2871 glw::GLubyte dummy_data[4] = {}; 2872 2873 try 2874 { 2875 /* Common preparations. */ 2876 gl.createBuffers(1, &buffer); 2877 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 2878 2879 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, 2880 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 2881 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 2882 2883 /* Test invalid buffer name error behavior. */ 2884 { 2885 /* Prepare for invalid buffer name error behavior verification. */ 2886 glw::GLuint not_a_buffer_name = 0; 2887 2888 while (gl.isBuffer(++not_a_buffer_name)) 2889 ; 2890 2891 /* Test. */ 2892 m_pClearNamedBufferSubData(not_a_buffer_name, GL_R8, 0, sizeof(dummy_data), GL_RGBA, GL_UNSIGNED_BYTE, 2893 &dummy_data); 2894 2895 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_OPERATION, 2896 " if buffer is not the name of an existing buffer object."); 2897 } 2898 2899 /* Test invalid sized internal format error behavior. */ 2900 { 2901 /* Prepare for invalid sized internal format error behavior verification. */ 2902 static const glw::GLenum valid_internal_formats[] = { 2903 GL_R8, GL_R16, GL_R16F, GL_R32F, GL_R8I, GL_R16I, GL_R32I, 2904 GL_R8UI, GL_R16UI, GL_R32UI, GL_RG8, GL_RG16, GL_RG16F, GL_RG32F, 2905 GL_RG8I, GL_RG16I, GL_RG32I, GL_RG8UI, GL_RG16UI, GL_RG32UI, GL_RGB32F, 2906 GL_RGB32I, GL_RGB32UI, GL_RGBA8, GL_RGBA16, GL_RGBA16F, GL_RGBA32F, GL_RGBA8I, 2907 GL_RGBA16I, GL_RGBA32I, GL_RGBA8UI, GL_RGBA16UI, GL_RGBA32UI, GL_NONE 2908 }; 2909 static const glw::GLenum valid_internal_formats_last = 2910 sizeof(valid_internal_formats) / sizeof(valid_internal_formats[0]) - 1; 2911 2912 glw::GLenum invalid_internal_format = 0; 2913 2914 while (&valid_internal_formats[valid_internal_formats_last] != 2915 std::find(&valid_internal_formats[0], &valid_internal_formats[valid_internal_formats_last], 2916 (++invalid_internal_format))) 2917 ; 2918 2919 /* Test. */ 2920 m_pClearNamedBufferData(buffer, invalid_internal_format, GL_RGBA, GL_UNSIGNED_BYTE, &dummy_data); 2921 2922 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_ENUM, 2923 " if internal format is not one of the valid sized internal formats " 2924 "(GL_R8, GL_R16, GL_R16F, GL_R32F, GL_R8I, GL_R16I, GL_R32I, GL_R8UI," 2925 " GL_R16UI, GL_R32UI, GL_RG8, GL_RG16, GL_RG16F, GL_RG32F, GL_RG8I, GL_RG16I," 2926 " GL_RG32I, GL_RG8UI, GL_RG16UI, GL_RG32UI, GL_RGB32F, GL_RGB32I, GL_RGB32UI," 2927 " GL_RGBA8, GL_RGBA16, GL_RGBA16F, GL_RGBA32F, GL_RGBA8I, GL_RGBA16I, GL_RGBA32I," 2928 " GL_RGBA8UI, GL_RGBA16UI, GL_RGBA32UI)."); 2929 } 2930 2931 /* Test incorrect offset alignment error behavior. */ 2932 { 2933 /* Test. */ 2934 m_pClearNamedBufferSubData(buffer, GL_RGBA8, sizeof(dummy_data[0]), sizeof(dummy_data), GL_RGBA, 2935 GL_UNSIGNED_BYTE, &dummy_data); 2936 2937 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_VALUE, 2938 "if offset is not multiples of the number of basic machine units (GLubyte)" 2939 "per-element for the internal format (GL_RGBA) specified by internal format."); 2940 } 2941 2942 /* Test incorrect range alignment error behavior. */ 2943 { 2944 m_pClearNamedBufferSubData(buffer, GL_RGBA8, 0, sizeof(dummy_data) - sizeof(dummy_data[0]), GL_RGBA, 2945 GL_UNSIGNED_BYTE, &dummy_data); 2946 2947 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_VALUE, 2948 "if range is not multiples of the number of basic machine units (GLubyte)" 2949 "per-element for the internal format (GL_RGBA) specified by internal format."); 2950 } 2951 2952 /* Test negative offset error behavior. */ 2953 { 2954 /* Test. */ 2955 m_pClearNamedBufferSubData(buffer, GL_R8, -1, sizeof(dummy_data), GL_RGBA, GL_UNSIGNED_BYTE, &dummy_data); 2956 2957 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_VALUE, " if offset or size is negative."); 2958 } 2959 2960 /* Test negative size error behavior. */ 2961 { 2962 /* Test. */ 2963 m_pClearNamedBufferSubData(buffer, GL_R8, 0, -((glw::GLsizei)sizeof(dummy_data)), GL_RGBA, GL_UNSIGNED_BYTE, 2964 &dummy_data); 2965 2966 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_VALUE, " if offset or size is negative."); 2967 } 2968 2969 /* Test size overflow error behavior. */ 2970 { 2971 /* Test. */ 2972 m_pClearNamedBufferSubData(buffer, GL_R8, 0, 2 * sizeof(dummy_data), GL_RGBA, GL_UNSIGNED_BYTE, 2973 &dummy_data); 2974 2975 is_ok &= ErrorCheckAndLog( 2976 "glClearNamedBufferSubData", GL_INVALID_VALUE, 2977 " if offset+size is greater than the value of BUFFER_SIZE for the specified buffer object."); 2978 } 2979 2980 /* Test of mapped buffer clear error behavior verification (glMapNamedBuffer version). */ 2981 { 2982 (void)(glw::GLbyte*) m_pMapNamedBuffer(buffer, GL_READ_ONLY); 2983 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 2984 2985 m_pClearNamedBufferSubData(buffer, GL_R8, 0, sizeof(dummy_data), GL_RGBA, GL_UNSIGNED_BYTE, &dummy_data); 2986 2987 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_OPERATION, 2988 " if any part of the specified range of the buffer" 2989 " object is mapped with MapBuffer, unless it was mapped with " 2990 "the MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags."); 2991 2992 m_pUnmapNamedBuffer(buffer); 2993 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 2994 } 2995 2996 /* Test of mapped buffer clear error behavior verification (glMapNamedBufferRange version). */ 2997 { 2998 (void)(glw::GLbyte*) m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 2999 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3000 3001 m_pClearNamedBufferSubData(buffer, GL_R8, 0, sizeof(dummy_data), GL_RGBA, GL_UNSIGNED_BYTE, &dummy_data); 3002 3003 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_INVALID_OPERATION, 3004 " if any part of the specified range of the buffer" 3005 " object is mapped with MapBufferRange, unless it was mapped with " 3006 "the MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags."); 3007 3008 m_pUnmapNamedBuffer(buffer); 3009 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3010 } 3011 3012 /* Test of persistently mapped buffer clear error with behavior verification (glMapNamedBufferRange version). */ 3013 { 3014 (void)(glw::GLbyte*) 3015 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT); 3016 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3017 3018 m_pClearNamedBufferSubData(buffer, GL_R8, 0, sizeof(dummy_data), GL_RGBA, GL_UNSIGNED_BYTE, &dummy_data); 3019 3020 is_ok &= ErrorCheckAndLog("glClearNamedBufferSubData", GL_NO_ERROR, 3021 " if any part of the specified range of the buffer" 3022 " object is mapped with MapBuffer with the MAP_PERSISTENT_BIT" 3023 " bit set in the MapBufferRange access flags."); 3024 3025 m_pUnmapNamedBuffer(buffer); 3026 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3027 } 3028 3029 /* Test invalid format error behavior. */ 3030 { 3031 /* Prepare for invalid format error behavior verification. */ 3032 static const glw::GLenum valid_formats[] = { GL_RED, GL_RG, 3033 GL_RGB, GL_BGR, 3034 GL_RGBA, GL_BGRA, 3035 GL_RED_INTEGER, GL_RG_INTEGER, 3036 GL_RGB_INTEGER, GL_BGR_INTEGER, 3037 GL_RGBA_INTEGER, GL_BGRA_INTEGER, 3038 GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, 3039 GL_DEPTH_STENCIL }; 3040 static const glw::GLenum valid_formats_last = sizeof(valid_formats) / sizeof(valid_formats[0]) - 1; 3041 3042 glw::GLenum invalid_format = 0; 3043 3044 while (&valid_formats[valid_formats_last] != 3045 std::find(&valid_formats[0], &valid_formats[valid_formats_last], (++invalid_format))) 3046 ; 3047 3048 /* Test. */ 3049 m_pClearNamedBufferSubData(buffer, GL_R8, 0, sizeof(dummy_data), invalid_format, GL_UNSIGNED_BYTE, 3050 &dummy_data); 3051 3052 is_ok &= ErrorCheckAndLog( 3053 "glClearNamedBufferSubData", GL_INVALID_ENUM, 3054 " if format is not a valid format " 3055 "(one of GL_RED, GL_RG, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, " 3056 "GL_RED_INTEGER, GL_RG_INTEGER, GL_RGB_INTEGER, GL_BGR_INTEGER, GL_RGBA_INTEGER, GL_BGRA_INTEGER, " 3057 "GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL)."); 3058 } 3059 3060 /* Test invalid type error behavior. */ 3061 { 3062 /* Prepare for invalid type error behavior verification. */ 3063 static const glw::GLenum valid_types[] = { GL_RED, GL_RG, 3064 GL_RGB, GL_BGR, 3065 GL_RGBA, GL_BGRA, 3066 GL_RED_INTEGER, GL_RG_INTEGER, 3067 GL_RGB_INTEGER, GL_BGR_INTEGER, 3068 GL_RGBA_INTEGER, GL_BGRA_INTEGER, 3069 GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, 3070 GL_DEPTH_STENCIL, GL_NONE }; 3071 static const glw::GLenum valid_types_last = sizeof(valid_types) / sizeof(valid_types[0]) - 1; 3072 3073 glw::GLenum invalid_type = 0; 3074 3075 while (&valid_types[valid_types_last] != 3076 std::find(&valid_types[0], &valid_types[valid_types_last], (++invalid_type))) 3077 ; 3078 3079 /* Test. */ 3080 m_pClearNamedBufferSubData(buffer, GL_R8, 0, sizeof(dummy_data), GL_RGBA, invalid_type, &dummy_data); 3081 3082 is_ok &= ErrorCheckAndLog( 3083 "glClearNamedBufferSubData", GL_INVALID_ENUM, 3084 " if format is not a valid type " 3085 "(one of GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, " 3086 "GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, " 3087 "GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, " 3088 "GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, " 3089 "GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, " 3090 "GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and GL_UNSIGNED_INT_2_10_10_10_REV)."); 3091 } 3092 } 3093 catch (...) 3094 { 3095 is_ok = false; 3096 internal_error = true; 3097 } 3098 3099 if (buffer) 3100 { 3101 gl.deleteBuffers(1, &buffer); 3102 3103 buffer = 0; 3104 } 3105 3106 if (internal_error) 3107 { 3108 throw 0; 3109 } 3110 3111 return is_ok; 3112 } 3113 3114 /** @brief Test Errors Of CopyNamedBufferSubData function. 3115 * 3116 * Check that INVALID_OPERATION is generated by CopyNamedBufferSubData if readBuffer 3117 * or writeBuffer is not the name of an existing buffer object. 3118 * 3119 * Check that INVALID_VALUE is generated by CopyNamedBufferSubData if any of 3120 * readOffset, writeOffset or size is negative, if readOffset+size is 3121 * greater than the size of the source buffer object (its value of 3122 * BUFFER_SIZE), or if writeOffset+size is greater than the size of the 3123 * destination buffer object. 3124 * 3125 * Check that INVALID_VALUE is generated by CopyNamedBufferSubData if the 3126 * source and destination are the same buffer object, and the ranges 3127 * [readOffset,readOffset+size) and [writeOffset,writeOffset+size) overlap. 3128 * 3129 * Check that INVALID_OPERATION is generated by CopyNamedBufferSubData if 3130 * either the source or destination buffer object is mapped with 3131 * MapBufferRange or MapBuffer, unless they were mapped with the 3132 * MAP_PERSISTENT bit set in the MapBufferRange access flags. 3133 * 3134 * True if test case succeeded, false otherwise. 3135 */ 3136 bool ErrorsTest::TestErrorsOfCopyNamedBufferSubData() 3137 { 3138 /* Shortcut for GL functionality. */ 3139 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3140 3141 /* Return value. */ 3142 bool is_ok = true; 3143 bool internal_error = false; 3144 3145 /* Common variables. */ 3146 glw::GLuint buffer_r = 0; 3147 glw::GLuint buffer_w = 0; 3148 glw::GLubyte dummy_data[4] = {}; 3149 3150 try 3151 { 3152 /* Common preparations. */ 3153 gl.createBuffers(1, &buffer_r); 3154 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 3155 3156 m_pNamedBufferStorage(buffer_r, sizeof(dummy_data), &dummy_data, 3157 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 3158 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 3159 3160 gl.createBuffers(1, &buffer_w); 3161 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 3162 3163 m_pNamedBufferStorage(buffer_w, sizeof(dummy_data), &dummy_data, 3164 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 3165 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 3166 3167 /* Test invalid buffer name error behavior. */ 3168 { 3169 /* Prepare for invalid buffer name error behavior verification. */ 3170 glw::GLuint not_a_buffer_name = 0; 3171 3172 while (gl.isBuffer(++not_a_buffer_name)) 3173 ; 3174 3175 /* Test. */ 3176 m_pCopyNamedBufferSubData(not_a_buffer_name, buffer_w, 0, 0, sizeof(dummy_data)); 3177 3178 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_OPERATION, 3179 " if readBuffer is not the name of an existing buffer object."); 3180 3181 m_pCopyNamedBufferSubData(buffer_r, not_a_buffer_name, 0, 0, sizeof(dummy_data)); 3182 3183 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_OPERATION, 3184 " if writeBuffer is not the name of an existing buffer object."); 3185 } 3186 3187 /* Test negative read offset error behavior. */ 3188 { 3189 /* Test. */ 3190 m_pCopyNamedBufferSubData(buffer_r, buffer_w, -1, 0, sizeof(dummy_data)); 3191 3192 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_VALUE, "if readOffset is negative."); 3193 } 3194 3195 /* Test negative write offset error behavior. */ 3196 { 3197 /* Test. */ 3198 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, -1, sizeof(dummy_data)); 3199 3200 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_VALUE, "if writeOffset is negative."); 3201 } 3202 3203 /* Test negative size error behavior. */ 3204 { 3205 /* Test. */ 3206 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, -1); 3207 3208 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_VALUE, "if size is negative."); 3209 } 3210 3211 /* Test overflow size error behavior. */ 3212 { 3213 /* Test. */ 3214 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, 2 * sizeof(dummy_data)); 3215 3216 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_VALUE, 3217 " if size is greater than the size of the source buffer object."); 3218 } 3219 3220 /* Test overflow read offset and size error behavior. */ 3221 { 3222 /* Test. */ 3223 m_pCopyNamedBufferSubData(buffer_r, buffer_w, sizeof(dummy_data) / 2, 0, sizeof(dummy_data)); 3224 3225 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_VALUE, 3226 " if readOffset+size is greater than the size of the source buffer object."); 3227 } 3228 3229 /* Test overflow write offset and size error behavior. */ 3230 { 3231 /* Test. */ 3232 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, sizeof(dummy_data) / 2, sizeof(dummy_data)); 3233 3234 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_VALUE, 3235 " if writeOffset+size is greater than the size of the source buffer object."); 3236 } 3237 3238 /* Test same buffer overlapping error behavior. */ 3239 { 3240 /* Test. */ 3241 m_pCopyNamedBufferSubData(buffer_w, buffer_w, 0, 0, sizeof(dummy_data)); 3242 3243 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_VALUE, 3244 " if the source and destination are the same buffer object, and the ranges" 3245 " [readOffset,readOffset+size) and [writeOffset,writeOffset+size) overlap."); 3246 } 3247 3248 /* Test of mapped read buffer copy error behavior verification (glMapNamedBuffer version). */ 3249 { 3250 (void)(glw::GLbyte*) m_pMapNamedBuffer(buffer_r, GL_READ_ONLY); 3251 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3252 3253 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, sizeof(dummy_data)); 3254 3255 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_OPERATION, 3256 " if the source buffer object is mapped with MapBuffer."); 3257 3258 m_pUnmapNamedBuffer(buffer_r); 3259 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3260 } 3261 3262 /* Test of mapped write buffer copy error behavior verification (glMapNamedBuffer version). */ 3263 { 3264 (void)(glw::GLbyte*) m_pMapNamedBuffer(buffer_w, GL_READ_ONLY); 3265 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3266 3267 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, sizeof(dummy_data)); 3268 3269 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_OPERATION, 3270 " if the destination buffer object is mapped with MapBuffer."); 3271 3272 m_pUnmapNamedBuffer(buffer_w); 3273 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3274 } 3275 3276 /* Test of mapped read buffer copy error behavior verification (glMapNamedBufferRange version). */ 3277 { 3278 (void)(glw::GLbyte*) m_pMapNamedBufferRange(buffer_r, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 3279 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3280 3281 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, sizeof(dummy_data)); 3282 3283 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_OPERATION, 3284 " if the source buffer object is mapped with MapBuffer."); 3285 3286 m_pUnmapNamedBuffer(buffer_r); 3287 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3288 } 3289 3290 /* Test of mapped write buffer copy error behavior verification (glMapNamedBufferRange version). */ 3291 { 3292 (void)(glw::GLbyte*) m_pMapNamedBufferRange(buffer_w, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 3293 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3294 3295 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, sizeof(dummy_data)); 3296 3297 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_INVALID_OPERATION, 3298 " if the destination buffer object is mapped with MapBuffer."); 3299 3300 m_pUnmapNamedBuffer(buffer_w); 3301 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3302 } 3303 3304 /* Test of persistently mapped read buffer copy error with behavior verification. */ 3305 { 3306 (void)(glw::GLbyte*) 3307 m_pMapNamedBufferRange(buffer_r, 0, sizeof(dummy_data), GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT); 3308 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3309 3310 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, sizeof(dummy_data)); 3311 3312 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_NO_ERROR, 3313 " if the source buffer object is mapped using " 3314 "MapBufferRange with the MAP_PERSISTENT bit " 3315 "set in the access flags."); 3316 3317 m_pUnmapNamedBuffer(buffer_r); 3318 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3319 } 3320 3321 /* Test of persistently mapped write buffer copy error with behavior verification. */ 3322 { 3323 (void)(glw::GLbyte*) 3324 m_pMapNamedBufferRange(buffer_w, 0, sizeof(dummy_data), GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT); 3325 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3326 3327 m_pCopyNamedBufferSubData(buffer_r, buffer_w, 0, 0, sizeof(dummy_data)); 3328 3329 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3330 is_ok &= ErrorCheckAndLog("glCopyNamedBufferSubData", GL_NO_ERROR, 3331 " if the destination buffer object is mapped using " 3332 "MapBufferRange with the MAP_PERSISTENT bit " 3333 "set in the access flags."); 3334 3335 m_pUnmapNamedBuffer(buffer_w); 3336 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3337 } 3338 } 3339 catch (...) 3340 { 3341 is_ok = false; 3342 internal_error = true; 3343 } 3344 3345 if (buffer_r) 3346 { 3347 gl.deleteBuffers(1, &buffer_r); 3348 3349 buffer_r = 0; 3350 } 3351 3352 if (buffer_r) 3353 { 3354 gl.deleteBuffers(1, &buffer_r); 3355 3356 buffer_r = 0; 3357 } 3358 3359 if (internal_error) 3360 { 3361 throw 0; 3362 } 3363 3364 return is_ok; 3365 } 3366 3367 /** @brief Test Errors Of CreateBuffers function. 3368 * 3369 * Check that INVALID_VALUE is generated by CreateBuffers if n is negative. 3370 * 3371 * True if test case succeeded, false otherwise. 3372 */ 3373 bool ErrorsTest::TestErrorsOfCreateBuffers() 3374 { 3375 /* Shortcut for GL functionality. */ 3376 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3377 3378 /* Return value. */ 3379 bool is_ok = true; 3380 3381 /* Test. */ 3382 glw::GLuint buffer = 0; 3383 3384 gl.createBuffers(-1, &buffer); 3385 3386 is_ok &= ErrorCheckAndLog("glCreateBuffers", GL_INVALID_VALUE, " if n is negative."); 3387 3388 /* Sanity check. */ 3389 if (buffer) 3390 { 3391 gl.deleteBuffers(1, &buffer); 3392 3393 /* Possible error cleanup. */ 3394 while (gl.getError()) 3395 ; 3396 } 3397 3398 return is_ok; 3399 } 3400 3401 /** @brief Test Errors Of FlushMappedNamedBufferRange function. 3402 * 3403 * Check that INVALID_OPERATION is generated by FlushMappedNamedBufferRange 3404 * if buffer is not the name of an existing buffer object. 3405 * 3406 * Check that INVALID_VALUE is generated by FlushMappedNamedBufferRange if 3407 * offset or length is negative, or if offset + length exceeds the size of 3408 * the mapping. 3409 * 3410 * Check that INVALID_OPERATION is generated by FlushMappedNamedBufferRange 3411 * if the buffer object is not mapped, or is mapped without the 3412 * MAP_FLUSH_EXPLICIT_BIT flag. 3413 * 3414 * True if test case succeeded, false otherwise. 3415 */ 3416 bool ErrorsTest::TestErrorsOfFlushMappedNamedBufferRange() 3417 { 3418 /* Shortcut for GL functionality. */ 3419 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3420 3421 /* Return value. */ 3422 bool is_ok = true; 3423 bool internal_error = false; 3424 3425 /* Common variables. */ 3426 glw::GLuint buffer = 0; 3427 glw::GLubyte dummy_data[4] = {}; 3428 3429 try 3430 { 3431 /* Common preparations. */ 3432 gl.createBuffers(1, &buffer); 3433 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 3434 3435 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 3436 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 3437 3438 /* Test invalid buffer name flush error behavior. */ 3439 { 3440 /* Prepare for invalid buffer name error behavior verification. */ 3441 glw::GLuint not_a_buffer_name = 0; 3442 3443 while (gl.isBuffer(++not_a_buffer_name)) 3444 ; 3445 3446 /* Test. */ 3447 m_pFlushMappedNamedBufferRange(not_a_buffer_name, 0, 1); 3448 3449 is_ok &= ErrorCheckAndLog("glFlushMappedNamedBufferRange", GL_INVALID_OPERATION, 3450 " if buffer is not the name of an existing buffer object."); 3451 } 3452 3453 /* Test negative offset flush error behavior. */ 3454 { 3455 (void)(glw::GLbyte*) 3456 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 3457 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3458 3459 m_pFlushMappedNamedBufferRange(buffer, -1, 1); 3460 3461 is_ok &= ErrorCheckAndLog("glFlushMappedNamedBufferRange", GL_INVALID_VALUE, " if offset is negative."); 3462 3463 m_pUnmapNamedBuffer(buffer); 3464 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3465 } 3466 3467 /* Test negative length flush error behavior. */ 3468 { 3469 (void)(glw::GLbyte*) 3470 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 3471 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3472 3473 m_pFlushMappedNamedBufferRange(buffer, 0, -1); 3474 3475 is_ok &= ErrorCheckAndLog("glFlushMappedNamedBufferRange", GL_INVALID_VALUE, " if length is negative."); 3476 3477 m_pUnmapNamedBuffer(buffer); 3478 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3479 } 3480 3481 /* Test length exceeds the mapping size flush error behavior. */ 3482 { 3483 (void)(glw::GLbyte*) 3484 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data) / 2, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 3485 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3486 3487 m_pFlushMappedNamedBufferRange(buffer, 0, sizeof(dummy_data)); 3488 3489 is_ok &= ErrorCheckAndLog("glFlushMappedNamedBufferRange", GL_INVALID_VALUE, 3490 " if length exceeds the size of the mapping."); 3491 3492 m_pUnmapNamedBuffer(buffer); 3493 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3494 } 3495 3496 /* Test offset + length exceeds the mapping size flush error behavior. */ 3497 { 3498 (void)(glw::GLbyte*) 3499 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 3500 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3501 3502 m_pFlushMappedNamedBufferRange(buffer, 1, sizeof(dummy_data)); 3503 3504 is_ok &= ErrorCheckAndLog("glFlushMappedNamedBufferRange", GL_INVALID_VALUE, 3505 " if offset + length exceeds the size of the mapping."); 3506 3507 m_pUnmapNamedBuffer(buffer); 3508 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3509 } 3510 3511 /* Test not mapped buffer flush error behavior. */ 3512 { 3513 m_pFlushMappedNamedBufferRange(buffer, 0, sizeof(dummy_data)); 3514 3515 is_ok &= ErrorCheckAndLog("glFlushMappedNamedBufferRange", GL_INVALID_OPERATION, 3516 " if the buffer object is not mapped."); 3517 } 3518 3519 /* Test buffer flush without the MAP_FLUSH_EXPLICIT_BIT error behavior. */ 3520 { 3521 (void)(glw::GLbyte*) m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_WRITE_BIT); 3522 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3523 3524 m_pFlushMappedNamedBufferRange(buffer, 0, sizeof(dummy_data)); 3525 3526 is_ok &= ErrorCheckAndLog("glFlushMappedNamedBufferRange", GL_INVALID_OPERATION, 3527 " if the buffer is mapped without the MAP_FLUSH_EXPLICIT_BIT flag."); 3528 3529 m_pUnmapNamedBuffer(buffer); 3530 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3531 } 3532 } 3533 catch (...) 3534 { 3535 is_ok = false; 3536 internal_error = true; 3537 } 3538 3539 if (buffer) 3540 { 3541 gl.deleteBuffers(1, &buffer); 3542 3543 buffer = 0; 3544 } 3545 3546 if (internal_error) 3547 { 3548 throw 0; 3549 } 3550 3551 return is_ok; 3552 } 3553 3554 /** @brief Test Errors Of GetNamedBufferParameteriv 3555 * and GetNamedBufferParameteri64v functions. 3556 * 3557 * Check that INVALID_OPERATION is generated by GetNamedBufferParameter* if 3558 * buffer is not the name of an existing buffer object. 3559 * 3560 * Check that INVALID_ENUM is generated by GetNamedBufferParameter* if 3561 * pname is not one of the buffer object parameter names: BUFFER_ACCESS, 3562 * BUFFER_ACCESS_FLAGS, BUFFER_IMMUTABLE_STORAGE, BUFFER_MAPPED, 3563 * BUFFER_MAP_LENGTH, BUFFER_MAP_OFFSET, BUFFER_SIZE, BUFFER_STORAGE_FLAGS, 3564 * BUFFER_USAGE. 3565 * 3566 * True if test case succeeded, false otherwise. 3567 */ 3568 bool ErrorsTest::TestErrorsOfGetNamedBufferParameter() 3569 { 3570 /* Shortcut for GL functionality. */ 3571 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3572 3573 /* Return value. */ 3574 bool is_ok = true; 3575 bool internal_error = false; 3576 3577 /* Common variables. */ 3578 glw::GLuint buffer = 0; 3579 glw::GLubyte dummy_data[4] = {}; 3580 3581 try 3582 { 3583 /* Common preparations. */ 3584 gl.createBuffers(1, &buffer); 3585 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 3586 3587 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 3588 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 3589 3590 /* Test invalid buffer name in GetNamedBufferParameteriv function error behavior. */ 3591 { 3592 /* Prepare for invalid buffer name error behavior verification. */ 3593 glw::GLuint not_a_buffer_name = 0; 3594 3595 while (gl.isBuffer(++not_a_buffer_name)) 3596 ; 3597 3598 glw::GLint value = 0; 3599 3600 /* Test. */ 3601 m_pGetNamedBufferParameteriv(not_a_buffer_name, GL_BUFFER_MAPPED, &value); 3602 3603 is_ok &= ErrorCheckAndLog("glGetNamedBufferParameteriv", GL_INVALID_OPERATION, 3604 " if buffer is not the name of an existing buffer object."); 3605 } 3606 3607 /* Test invalid buffer name in GetNamedBufferParameteri64v function error behavior. */ 3608 { 3609 /* Prepare for invalid buffer name error behavior verification. */ 3610 glw::GLuint not_a_buffer_name = 0; 3611 3612 while (gl.isBuffer(++not_a_buffer_name)) 3613 ; 3614 3615 glw::GLint64 value = 0; 3616 3617 /* Test. */ 3618 m_pGetNamedBufferParameteri64v(not_a_buffer_name, GL_BUFFER_MAPPED, &value); 3619 3620 is_ok &= ErrorCheckAndLog("glGetNamedBufferParameteri64v", GL_INVALID_OPERATION, 3621 " if buffer is not the name of an existing buffer object."); 3622 } 3623 3624 /* Test invalid parameter name in GetNamedBufferParameteriv function error behavior. */ 3625 { 3626 /* Prepare for invalid parameter name error behavior verification. */ 3627 static const glw::GLenum valid_parameters[] = { 3628 GL_BUFFER_ACCESS, GL_BUFFER_ACCESS_FLAGS, GL_BUFFER_IMMUTABLE_STORAGE, 3629 GL_BUFFER_MAPPED, GL_BUFFER_MAP_LENGTH, GL_BUFFER_MAP_OFFSET, 3630 GL_BUFFER_SIZE, GL_BUFFER_STORAGE_FLAGS, GL_BUFFER_USAGE, 3631 GL_NONE 3632 }; 3633 static const glw::GLenum valid_parameters_last = sizeof(valid_parameters) / sizeof(valid_parameters[0]) - 1; 3634 3635 glw::GLint value = 0; 3636 3637 glw::GLenum invalid_parameter = 0; 3638 3639 while (&valid_parameters[valid_parameters_last] != 3640 std::find(&valid_parameters[0], &valid_parameters[valid_parameters_last], (++invalid_parameter))) 3641 ; 3642 3643 /* Test. */ 3644 m_pGetNamedBufferParameteriv(buffer, invalid_parameter, &value); 3645 3646 is_ok &= ErrorCheckAndLog("glGetNamedBufferParameteriv", GL_INVALID_ENUM, 3647 " if pname is not one of the buffer object parameter names: BUFFER_ACCESS," 3648 " BUFFER_ACCESS_FLAGS, BUFFER_IMMUTABLE_STORAGE, BUFFER_MAPPED," 3649 " BUFFER_MAP_LENGTH, BUFFER_MAP_OFFSET, BUFFER_SIZE, BUFFER_STORAGE_FLAGS," 3650 " BUFFER_USAGE."); 3651 } 3652 3653 /* Test invalid parameter name in GetNamedBufferParameteri64v function error behavior. */ 3654 { 3655 /* Prepare for invalid parameter name error behavior verification. */ 3656 static const glw::GLenum valid_parameters[] = { 3657 GL_BUFFER_ACCESS, GL_BUFFER_ACCESS_FLAGS, GL_BUFFER_IMMUTABLE_STORAGE, 3658 GL_BUFFER_MAPPED, GL_BUFFER_MAP_LENGTH, GL_BUFFER_MAP_OFFSET, 3659 GL_BUFFER_SIZE, GL_BUFFER_STORAGE_FLAGS, GL_BUFFER_USAGE, 3660 GL_NONE 3661 }; 3662 static const glw::GLenum valid_parameters_last = sizeof(valid_parameters) / sizeof(valid_parameters[0]) - 1; 3663 3664 glw::GLint64 value = 0; 3665 3666 glw::GLenum invalid_parameter = 0; 3667 3668 while (&valid_parameters[valid_parameters_last] != 3669 std::find(&valid_parameters[0], &valid_parameters[valid_parameters_last], (++invalid_parameter))) 3670 ; 3671 3672 /* Test. */ 3673 m_pGetNamedBufferParameteri64v(buffer, invalid_parameter, &value); 3674 3675 is_ok &= ErrorCheckAndLog("glGetNamedBufferParameteri64v", GL_INVALID_ENUM, 3676 " if pname is not one of the buffer object parameter names: BUFFER_ACCESS," 3677 " BUFFER_ACCESS_FLAGS, BUFFER_IMMUTABLE_STORAGE, BUFFER_MAPPED," 3678 " BUFFER_MAP_LENGTH, BUFFER_MAP_OFFSET, BUFFER_SIZE, BUFFER_STORAGE_FLAGS," 3679 " BUFFER_USAGE."); 3680 } 3681 } 3682 catch (...) 3683 { 3684 is_ok = false; 3685 internal_error = true; 3686 } 3687 3688 if (buffer) 3689 { 3690 gl.deleteBuffers(1, &buffer); 3691 3692 buffer = 0; 3693 } 3694 3695 if (internal_error) 3696 { 3697 throw 0; 3698 } 3699 3700 return is_ok; 3701 } 3702 3703 /** @brief Test Errors Of GetNamedBufferPointerv function. 3704 * 3705 * Check that INVALID_OPERATION is generated by GetNamedBufferPointerv 3706 * if buffer is not the name of an existing buffer object. 3707 * 3708 * True if test case succeeded, false otherwise. 3709 */ 3710 bool ErrorsTest::TestErrorsOfGetNamedBufferPointerv() 3711 { 3712 /* Shortcut for GL functionality. */ 3713 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3714 3715 /* Return value. */ 3716 bool is_ok = true; 3717 bool internal_error = false; 3718 3719 /* Common variables. */ 3720 glw::GLuint buffer = 0; 3721 glw::GLubyte dummy_data[4] = {}; 3722 3723 try 3724 { 3725 /* Common preparations. */ 3726 gl.createBuffers(1, &buffer); 3727 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 3728 3729 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 3730 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 3731 3732 /* Test invalid buffer name in GetNamedBufferPointerv function error behavior. */ 3733 { 3734 /* Prepare for invalid buffer name error behavior verification. */ 3735 glw::GLuint not_a_buffer_name = 0; 3736 3737 while (gl.isBuffer(++not_a_buffer_name)) 3738 ; 3739 3740 glw::GLvoid* pointer = DE_NULL; 3741 3742 /* Test. */ 3743 m_pGetNamedBufferPointerv(not_a_buffer_name, GL_BUFFER_MAP_POINTER, &pointer); 3744 3745 is_ok &= ErrorCheckAndLog("glGetNamedBufferPointerv", GL_INVALID_OPERATION, 3746 " if buffer is not the name of an existing buffer object."); 3747 } 3748 } 3749 catch (...) 3750 { 3751 is_ok = false; 3752 internal_error = true; 3753 } 3754 3755 if (buffer) 3756 { 3757 gl.deleteBuffers(1, &buffer); 3758 3759 buffer = 0; 3760 } 3761 3762 if (internal_error) 3763 { 3764 throw 0; 3765 } 3766 3767 return is_ok; 3768 } 3769 3770 /** @brief Test Errors Of GetNamedBufferSubData function. 3771 * 3772 * Check that INVALID_OPERATION is generated by GetNamedBufferSubData if 3773 * buffer is not the name of an existing buffer object. 3774 * 3775 * Check that INVALID_VALUE is generated by GetNamedBufferSubData if offset 3776 * or size is negative, or if offset+size is greater than the value of 3777 * BUFFER_SIZE for the buffer object. 3778 * 3779 * Check that INVALID_OPERATION is generated by GetNamedBufferSubData if 3780 * the buffer object is mapped with MapBufferRange or MapBuffer, unless it 3781 * was mapped with the MAP_PERSISTENT_BIT bit set in the MapBufferRange 3782 * access flags. 3783 * 3784 * True if test case succeeded, false otherwise. 3785 */ 3786 bool ErrorsTest::TestErrorsOfGetNamedBufferSubData() 3787 { 3788 /* Shortcut for GL functionality. */ 3789 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3790 3791 /* Return value. */ 3792 bool is_ok = true; 3793 bool internal_error = false; 3794 3795 /* Common variables. */ 3796 glw::GLuint buffer = 0; 3797 glw::GLubyte dummy_data[4] = {}; 3798 3799 try 3800 { 3801 /* Common preparations. */ 3802 gl.createBuffers(1, &buffer); 3803 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 3804 3805 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 3806 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 3807 3808 /* Test invalid buffer name in pGetNamedBufferSubData function error behavior. */ 3809 { 3810 /* Prepare for invalid buffer name error behavior verification. */ 3811 glw::GLuint not_a_buffer_name = 0; 3812 3813 while (gl.isBuffer(++not_a_buffer_name)) 3814 ; 3815 3816 /* Query storage. */ 3817 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3818 3819 /* Test. */ 3820 m_pGetNamedBufferSubData(not_a_buffer_name, 0, sizeof(dummy_data_query), dummy_data_query); 3821 3822 is_ok &= ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_OPERATION, 3823 " if buffer is not the name of an existing buffer object."); 3824 } 3825 3826 /* Test negative offset error behavior. */ 3827 { 3828 /* Query storage. */ 3829 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3830 3831 /* Test. */ 3832 m_pGetNamedBufferSubData(buffer, -1, sizeof(dummy_data_query), dummy_data_query); 3833 3834 is_ok &= ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_VALUE, " if offset is negative."); 3835 } 3836 3837 /* Test negative size error behavior. */ 3838 { 3839 /* Query storage. */ 3840 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3841 3842 /* Test. */ 3843 m_pGetNamedBufferSubData(buffer, 0, -1, dummy_data_query); 3844 3845 is_ok &= ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_VALUE, " if size is negative."); 3846 } 3847 3848 /* Test size overflow error behavior. */ 3849 { 3850 /* Query storage. */ 3851 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3852 3853 /* Test. */ 3854 m_pGetNamedBufferSubData(buffer, 0, 2 * sizeof(dummy_data_query), dummy_data_query); 3855 3856 is_ok &= ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_VALUE, 3857 " if size is greater than the value of BUFFER_SIZE for the buffer object."); 3858 } 3859 3860 /* Test offset+size overflow error behavior. */ 3861 { 3862 /* Query storage. */ 3863 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3864 3865 /* Test. */ 3866 m_pGetNamedBufferSubData(buffer, sizeof(dummy_data_query) / 2, sizeof(dummy_data_query), dummy_data_query); 3867 3868 is_ok &= 3869 ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_VALUE, 3870 " if offset+size is greater than the value of BUFFER_SIZE for the buffer object."); 3871 } 3872 3873 /* Test offset overflow error behavior. */ 3874 { 3875 /* Query storage. */ 3876 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3877 3878 /* Test. */ 3879 m_pGetNamedBufferSubData(buffer, sizeof(dummy_data_query) + 1, 0, dummy_data_query); 3880 3881 is_ok &= ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_VALUE, 3882 " if offset is greater than the value of BUFFER_SIZE for the buffer object."); 3883 } 3884 3885 /* Test mapped buffer query error behavior. */ 3886 { 3887 /* Query storage. */ 3888 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3889 3890 /* Test. */ 3891 (void)(glw::GLbyte*) m_pMapNamedBuffer(buffer, GL_WRITE_ONLY); 3892 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3893 3894 m_pGetNamedBufferSubData(buffer, 0, sizeof(dummy_data_query), dummy_data_query); 3895 3896 is_ok &= ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_OPERATION, 3897 " if the buffer object is mapped with MapBufferRange."); 3898 3899 m_pUnmapNamedBuffer(buffer); 3900 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3901 } 3902 3903 /* Test mapped buffer query error behavior. */ 3904 { 3905 /* Query storage. */ 3906 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3907 3908 /* Test. */ 3909 (void)(glw::GLbyte*) m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_WRITE_BIT); 3910 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3911 3912 m_pGetNamedBufferSubData(buffer, 0, sizeof(dummy_data_query), dummy_data_query); 3913 3914 is_ok &= ErrorCheckAndLog("glGetNamedBufferSubData", GL_INVALID_OPERATION, 3915 " if the buffer object is mapped with MapBufferRange."); 3916 3917 m_pUnmapNamedBuffer(buffer); 3918 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3919 } 3920 3921 /* Test persistently mapped buffer query behavior. */ 3922 { 3923 /* Query storage. */ 3924 glw::GLubyte dummy_data_query[sizeof(dummy_data) / sizeof(dummy_data[0])] = {}; 3925 3926 /* Test. */ 3927 (void)(glw::GLbyte*) 3928 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 3929 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 3930 3931 m_pGetNamedBufferSubData(buffer, 0, sizeof(dummy_data_query), dummy_data_query); 3932 3933 is_ok &= ErrorCheckAndLog( 3934 "glGetNamedBufferSubData", GL_NO_ERROR, 3935 " if the buffer object is mapped with MapBufferRange with GL_MAP_PERSISTENT_BIT flag."); 3936 3937 m_pUnmapNamedBuffer(buffer); 3938 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 3939 } 3940 } 3941 catch (...) 3942 { 3943 is_ok = false; 3944 internal_error = true; 3945 } 3946 3947 if (buffer) 3948 { 3949 gl.deleteBuffers(1, &buffer); 3950 3951 buffer = 0; 3952 } 3953 3954 if (internal_error) 3955 { 3956 throw 0; 3957 } 3958 3959 return is_ok; 3960 } 3961 3962 /** @brief Test Errors Of MapNamedBuffer function. 3963 * 3964 * Check that INVALID_OPERATION is generated by MapNamedBuffer if buffer is 3965 * not the name of an existing buffer object. 3966 * 3967 * Check that INVALID_ENUM is generated by MapNamedBuffer if access is not 3968 * READ_ONLY, WRITE_ONLY, or READ_WRITE. 3969 * 3970 * Check that INVALID_OPERATION is generated by MapNamedBuffer if the 3971 * buffer object is in a mapped state. 3972 * 3973 * True if test case succeeded, false otherwise. 3974 */ 3975 bool ErrorsTest::TestErrorsOfMapNamedBuffer() 3976 { 3977 /* Shortcut for GL functionality. */ 3978 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 3979 3980 /* Return value. */ 3981 bool is_ok = true; 3982 bool internal_error = false; 3983 3984 /* Common variables. */ 3985 glw::GLuint buffer = 0; 3986 glw::GLubyte dummy_data[4] = {}; 3987 3988 try 3989 { 3990 /* Common preparations. */ 3991 gl.createBuffers(1, &buffer); 3992 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 3993 3994 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT); 3995 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 3996 3997 /* Test invalid buffer name error behavior. */ 3998 { 3999 /* Prepare for invalid buffer name error behavior verification. */ 4000 glw::GLuint not_a_buffer_name = 0; 4001 4002 while (gl.isBuffer(++not_a_buffer_name)) 4003 ; 4004 4005 /* Test. */ 4006 m_pMapNamedBuffer(not_a_buffer_name, GL_READ_ONLY); 4007 4008 is_ok &= ErrorCheckAndLog("glMapNamedBuffer", GL_INVALID_OPERATION, 4009 " if buffer is not the name of an existing buffer object."); 4010 } 4011 4012 /* Test access flag error behavior. */ 4013 { 4014 /* Prepare for invalid type error behavior verification. */ 4015 static const glw::GLenum valid_access_flags[] = { GL_READ_ONLY, GL_WRITE_ONLY, GL_READ_WRITE, GL_NONE }; 4016 static const glw::GLenum valid_access_flags_last = 4017 sizeof(valid_access_flags) / sizeof(valid_access_flags[0]) - 1; 4018 4019 glw::GLenum invalid_access_flags = 0; 4020 4021 while (&valid_access_flags[valid_access_flags_last] != 4022 std::find(&valid_access_flags[0], &valid_access_flags[valid_access_flags_last], 4023 (++invalid_access_flags))) 4024 ; 4025 4026 /* Test. */ 4027 glw::GLbyte* mapped_data = (glw::GLbyte*)m_pMapNamedBuffer(buffer, invalid_access_flags); 4028 4029 is_ok &= ErrorCheckAndLog("glMapNamedBuffer", GL_INVALID_ENUM, 4030 " if access is not READ_ONLY, WRITE_ONLY, or READ_WRITE."); 4031 4032 /* Sanity unmapping. */ 4033 if (DE_NULL != mapped_data) 4034 { 4035 m_pUnmapNamedBuffer(buffer); 4036 while (gl.getError()) 4037 ; 4038 } 4039 } 4040 4041 /* Test mapping of mapped buffer error behavior. */ 4042 { 4043 (void)(glw::GLbyte*) m_pMapNamedBuffer(buffer, GL_READ_ONLY); 4044 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer."); 4045 4046 glw::GLbyte* subsequent_mapped_data = (glw::GLbyte*)m_pMapNamedBuffer(buffer, GL_READ_ONLY); 4047 4048 is_ok &= ErrorCheckAndLog("glMapNamedBuffer", GL_INVALID_OPERATION, 4049 " if the buffer object is in a mapped state."); 4050 4051 m_pUnmapNamedBuffer(buffer); 4052 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 4053 4054 if (subsequent_mapped_data) 4055 { 4056 m_context.getTestContext().getLog() 4057 << tcu::TestLog::Message 4058 << "glMapNamedBuffer called on mapped buffer returned non-NULL pointer when error shall occure." 4059 "This may lead to undefined behavior during next tests (object still may be mapped). " 4060 "Test was terminated prematurely." 4061 << tcu::TestLog::EndMessage; 4062 throw 0; 4063 } 4064 } 4065 } 4066 catch (...) 4067 { 4068 is_ok = false; 4069 internal_error = true; 4070 } 4071 4072 if (buffer) 4073 { 4074 gl.deleteBuffers(1, &buffer); 4075 4076 buffer = 0; 4077 } 4078 4079 if (internal_error) 4080 { 4081 throw 0; 4082 } 4083 4084 return is_ok; 4085 } 4086 4087 /** @brief Test Errors Of MapNamedBufferRange function. 4088 * 4089 * Check that INVALID_OPERATION is generated by MapNamedBufferRange if 4090 * buffer is not the name of an existing buffer object. 4091 * 4092 * Check that INVALID_VALUE is generated by MapNamedBufferRange if offset 4093 * or length is negative, if offset+length is greater than the value of 4094 * BUFFER_SIZE for the buffer object, or if access has any bits set other 4095 * than those defined above. 4096 * 4097 * Check that INVALID_OPERATION is generated by MapNamedBufferRange for any 4098 * of the following conditions: 4099 * - length is zero. 4100 * - The buffer object is already in a mapped state. 4101 * - Neither MAP_READ_BIT nor MAP_WRITE_BIT is set. 4102 * - MAP_READ_BIT is set and any of MAP_INVALIDATE_RANGE_BIT, 4103 * MAP_INVALIDATE_BUFFER_BIT or MAP_UNSYNCHRONIZED_BIT is set. 4104 * - MAP_FLUSH_EXPLICIT_BIT is set and MAP_WRITE_BIT is not set. 4105 * - Any of MAP_READ_BIT, MAP_WRITE_BIT, MAP_PERSISTENT_BIT, or 4106 * MAP_COHERENT_BIT are set, but the same bit is not included in the 4107 * buffer's storage flags. 4108 * 4109 * True if test case succeeded, false otherwise. 4110 */ 4111 bool ErrorsTest::TestErrorsOfMapNamedBufferRange() 4112 { 4113 /* Shortcut for GL functionality. */ 4114 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4115 4116 /* Return value. */ 4117 bool is_ok = true; 4118 bool internal_error = false; 4119 4120 /* Common variables. */ 4121 glw::GLuint buffer = 0; 4122 glw::GLuint buffer_special_flags = 0; 4123 glw::GLubyte dummy_data[4] = {}; 4124 4125 try 4126 { 4127 /* Common preparations. */ 4128 gl.createBuffers(1, &buffer); 4129 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4130 4131 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, 4132 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT); 4133 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 4134 4135 /* Test invalid buffer name error behavior. */ 4136 { 4137 /* Prepare for invalid buffer name error behavior verification. */ 4138 glw::GLuint not_a_buffer_name = 0; 4139 4140 while (gl.isBuffer(++not_a_buffer_name)) 4141 ; 4142 4143 /* Test. */ 4144 m_pMapNamedBufferRange(not_a_buffer_name, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 4145 4146 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_OPERATION, 4147 " if buffer is not the name of an existing buffer object."); 4148 } 4149 4150 /* Test negative offset error behavior. */ 4151 { 4152 glw::GLvoid* mapped_data = m_pMapNamedBufferRange(buffer, -1, sizeof(dummy_data), GL_MAP_READ_BIT); 4153 4154 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_VALUE, " if offset is negative."); 4155 4156 /* Sanity unmapping. */ 4157 if (DE_NULL != mapped_data) 4158 { 4159 m_pUnmapNamedBuffer(buffer); 4160 while (gl.getError()) 4161 ; 4162 } 4163 } 4164 4165 /* Test negative length error behavior. */ 4166 { 4167 glw::GLvoid* mapped_data = m_pMapNamedBufferRange(buffer, 0, -1, GL_MAP_READ_BIT); 4168 4169 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_VALUE, " if length is negative."); 4170 4171 /* Sanity unmapping. */ 4172 if (DE_NULL != mapped_data) 4173 { 4174 m_pUnmapNamedBuffer(buffer); 4175 while (gl.getError()) 4176 ; 4177 } 4178 } 4179 4180 /* Test length overflow error behavior. */ 4181 { 4182 glw::GLvoid* mapped_data = m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data) * 2, GL_MAP_READ_BIT); 4183 4184 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_VALUE, 4185 " if length is greater than the value of BUFFER_SIZE" 4186 " for the buffer object, or if access has any bits set other" 4187 " than those defined above."); 4188 4189 /* Sanity unmapping. */ 4190 if (DE_NULL != mapped_data) 4191 { 4192 m_pUnmapNamedBuffer(buffer); 4193 while (gl.getError()) 4194 ; 4195 } 4196 } 4197 4198 /* Test (offset+length) overflow error behavior. */ 4199 { 4200 glw::GLvoid* mapped_data = 4201 m_pMapNamedBufferRange(buffer, sizeof(dummy_data) / 2, sizeof(dummy_data), GL_MAP_READ_BIT); 4202 4203 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_VALUE, 4204 " if offset+length is greater than the value of BUFFER_SIZE" 4205 " for the buffer object, or if access has any bits set other" 4206 " than those defined above."); 4207 4208 /* Sanity unmapping. */ 4209 if (DE_NULL != mapped_data) 4210 { 4211 m_pUnmapNamedBuffer(buffer); 4212 while (gl.getError()) 4213 ; 4214 } 4215 } 4216 4217 /* Test zero length error behavior. */ 4218 { 4219 glw::GLvoid* mapped_data = m_pMapNamedBufferRange(buffer, 0, 0, GL_MAP_READ_BIT); 4220 4221 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_OPERATION, " if length is zero."); 4222 4223 /* Sanity unmapping. */ 4224 if (DE_NULL != mapped_data) 4225 { 4226 m_pUnmapNamedBuffer(buffer); 4227 while (gl.getError()) 4228 ; 4229 } 4230 } 4231 4232 /* Test mapping of mapped buffer error behavior. */ 4233 { 4234 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 4235 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer."); 4236 4237 glw::GLvoid* subsequent_mapped_data = 4238 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 4239 4240 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_OPERATION, 4241 " if the buffer object is in a mapped state."); 4242 4243 m_pUnmapNamedBuffer(buffer); 4244 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 4245 4246 if (subsequent_mapped_data) 4247 { 4248 m_context.getTestContext().getLog() 4249 << tcu::TestLog::Message 4250 << "glMapNamedBufferRange called on mapped buffer returned non-NULL pointer when error shall " 4251 "occure." 4252 "This may lead to undefined behavior during next tests (object still may be mapped). " 4253 "Test was terminated prematurely." 4254 << tcu::TestLog::EndMessage; 4255 throw 0; 4256 } 4257 } 4258 4259 /* Test access flag read and write bits are not set error behavior. */ 4260 { 4261 glw::GLvoid* mapped_data = m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), 0); 4262 4263 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_OPERATION, 4264 " if neither MAP_READ_BIT nor MAP_WRITE_BIT is set."); 4265 4266 /* Sanity unmapping. */ 4267 if (DE_NULL != mapped_data) 4268 { 4269 m_pUnmapNamedBuffer(buffer); 4270 while (gl.getError()) 4271 ; 4272 } 4273 } 4274 4275 /* Test read access invalid flags error behavior. */ 4276 { 4277 glw::GLenum read_access_invalid_flags[] = { GL_MAP_INVALIDATE_RANGE_BIT, GL_MAP_INVALIDATE_BUFFER_BIT, 4278 GL_MAP_UNSYNCHRONIZED_BIT }; 4279 const glw::GLchar* read_access_invalid_flags_log[] = { 4280 " if MAP_READ_BIT is set with MAP_INVALIDATE_RANGE_BIT.", 4281 " if MAP_READ_BIT is set with MAP_INVALIDATE_BUFFER_BIT.", 4282 " if MAP_READ_BIT is set with MAP_UNSYNCHRONIZED_BIT." 4283 }; 4284 glw::GLuint read_access_invalid_flags_count = 4285 sizeof(read_access_invalid_flags) / sizeof(read_access_invalid_flags[0]); 4286 4287 for (glw::GLuint i = 0; i < read_access_invalid_flags_count; ++i) 4288 { 4289 glw::GLvoid* mapped_data = m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), 4290 GL_MAP_READ_BIT | read_access_invalid_flags[i]); 4291 4292 is_ok &= 4293 ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_OPERATION, read_access_invalid_flags_log[i]); 4294 4295 /* Sanity unmapping. */ 4296 if (DE_NULL != mapped_data) 4297 { 4298 m_pUnmapNamedBuffer(buffer); 4299 while (gl.getError()) 4300 ; 4301 } 4302 } 4303 } 4304 4305 /* Test access flush bit without write bit error behavior. */ 4306 { 4307 glw::GLvoid* mapped_data = 4308 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 4309 4310 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_OPERATION, 4311 " if MAP_FLUSH_EXPLICIT_BIT is set and MAP_WRITE_BIT is not set."); 4312 4313 /* Sanity unmapping. */ 4314 if (DE_NULL != mapped_data) 4315 { 4316 m_pUnmapNamedBuffer(buffer); 4317 while (gl.getError()) 4318 ; 4319 } 4320 } 4321 4322 /* Test incompatible buffer flag error behavior. */ 4323 { 4324 glw::GLenum buffer_flags[] = { GL_MAP_WRITE_BIT, GL_MAP_READ_BIT, GL_MAP_WRITE_BIT, 4325 GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT }; 4326 glw::GLenum mapping_flags[] = { GL_MAP_READ_BIT, GL_MAP_WRITE_BIT, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT, 4327 GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT }; 4328 const glw::GLchar* mapping_flags_log[] = { 4329 " if MAP_READ_BIT is set, but the same bit is not included in the buffer's storage flags.", 4330 " if MAP_WRITE_BIT is set, but the same bit is not included in the buffer's storage flags.", 4331 " if MAP_PERSISTENT_BIT is set, but the same bit is not included in the buffer's storage flags.", 4332 " if MAP_COHERENT_BIT is set, but the same bit is not included in the buffer's storage flags." 4333 }; 4334 glw::GLuint flags_count = sizeof(mapping_flags) / sizeof(mapping_flags[0]); 4335 4336 for (glw::GLuint i = 0; i < flags_count; ++i) 4337 { 4338 /* Create buffer. */ 4339 gl.createBuffers(1, &buffer_special_flags); 4340 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4341 4342 m_pNamedBufferStorage(buffer_special_flags, sizeof(dummy_data), &dummy_data, buffer_flags[i]); 4343 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 4344 4345 /* Test mapping. */ 4346 glw::GLvoid* mapped_data = 4347 m_pMapNamedBufferRange(buffer_special_flags, 0, sizeof(dummy_data), mapping_flags[i]); 4348 4349 is_ok &= ErrorCheckAndLog("glMapNamedBufferRange", GL_INVALID_OPERATION, mapping_flags_log[i]); 4350 4351 /* Sanity unmapping. */ 4352 if (DE_NULL != mapped_data) 4353 { 4354 m_pUnmapNamedBuffer(buffer); 4355 while (gl.getError()) 4356 ; 4357 } 4358 4359 /* Releasing buffer. */ 4360 if (buffer_special_flags) 4361 { 4362 gl.deleteBuffers(1, &buffer_special_flags); 4363 4364 buffer_special_flags = 0; 4365 } 4366 } 4367 } 4368 } 4369 catch (...) 4370 { 4371 is_ok = false; 4372 internal_error = true; 4373 } 4374 4375 if (buffer) 4376 { 4377 gl.deleteBuffers(1, &buffer); 4378 4379 buffer = 0; 4380 } 4381 4382 if (buffer_special_flags) 4383 { 4384 gl.deleteBuffers(1, &buffer_special_flags); 4385 4386 buffer_special_flags = 0; 4387 } 4388 4389 if (internal_error) 4390 { 4391 throw 0; 4392 } 4393 4394 return is_ok; 4395 } 4396 4397 /** @brief Test Errors Of NamedBufferData function. 4398 * 4399 * Check that INVALID_OPERATION is generated by NamedBufferData if buffer 4400 * is not the name of an existing buffer object. 4401 * 4402 * Check that INVALID_ENUM is generated by NamedBufferData if usage is not 4403 * STREAM_DRAW, STREAM_READ, STREAM_COPY, STATIC_DRAW, STATIC_READ, 4404 * STATIC_COPY, DYNAMIC_DRAW, DYNAMIC_READ or DYNAMIC_COPY. 4405 * 4406 * Check that INVALID_VALUE is generated by NamedBufferData if size is 4407 * negative. 4408 * 4409 * Check that INVALID_OPERATION is generated by NamedBufferData if the 4410 * BUFFER_IMMUTABLE_STORAGE flag of the buffer object is TRUE. 4411 * 4412 * True if test case succeeded, false otherwise. 4413 */ 4414 bool ErrorsTest::TestErrorsOfNamedBufferData() 4415 { 4416 /* Shortcut for GL functionality. */ 4417 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4418 4419 /* Return value. */ 4420 bool is_ok = true; 4421 bool internal_error = false; 4422 4423 /* Common variables. */ 4424 glw::GLuint buffer = 0; 4425 glw::GLuint immutable_buffer = 0; 4426 glw::GLubyte dummy_data[4] = {}; 4427 std::stack<glw::GLuint> too_much_buffers; 4428 4429 try 4430 { 4431 /* Common preparations. */ 4432 gl.createBuffers(1, &buffer); 4433 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4434 4435 gl.createBuffers(1, &immutable_buffer); 4436 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4437 4438 m_pNamedBufferStorage(immutable_buffer, sizeof(dummy_data), &dummy_data, GL_MAP_READ_BIT); 4439 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 4440 4441 /* Test invalid buffer name error behavior. */ 4442 { 4443 /* Prepare for invalid buffer name error behavior verification. */ 4444 glw::GLuint not_a_buffer_name = 0; 4445 4446 while (gl.isBuffer(++not_a_buffer_name)) 4447 ; 4448 4449 /* Test. */ 4450 m_pNamedBufferData(not_a_buffer_name, sizeof(dummy_data), dummy_data, GL_DYNAMIC_COPY); 4451 4452 is_ok &= ErrorCheckAndLog("glNamedBufferData", GL_INVALID_OPERATION, 4453 " if buffer is not the name of an existing buffer object."); 4454 } 4455 4456 /* Test invalid usage error behavior. */ 4457 { 4458 /* Prepare for invalid type error behavior verification. */ 4459 static const glw::GLenum valid_usages[] = { GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, 4460 GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, 4461 GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, GL_DYNAMIC_COPY, 4462 GL_NONE }; 4463 static const glw::GLenum valid_usages_last = sizeof(valid_usages) / sizeof(valid_usages[0]) - 1; 4464 4465 glw::GLenum invalid_usage = 0; 4466 4467 while (&valid_usages[valid_usages_last] != 4468 std::find(&valid_usages[0], &valid_usages[valid_usages_last], (++invalid_usage))) 4469 ; 4470 4471 /* Test. */ 4472 m_pNamedBufferData(buffer, sizeof(dummy_data), dummy_data, invalid_usage); 4473 4474 is_ok &= 4475 ErrorCheckAndLog("glNamedBufferData", GL_INVALID_ENUM, 4476 " if usage is not STREAM_DRAW, STREAM_READ, STREAM_COPY, STATIC_DRAW, STATIC_READ," 4477 " STATIC_COPY, DYNAMIC_DRAW, DYNAMIC_READ or DYNAMIC_COPY."); 4478 } 4479 4480 /* Test negative size error behavior. */ 4481 { 4482 m_pNamedBufferData(buffer, -1, dummy_data, GL_DYNAMIC_COPY); 4483 4484 is_ok &= ErrorCheckAndLog("glNamedBufferData", GL_INVALID_VALUE, " if size is negative."); 4485 } 4486 4487 /* Test immutable buffer error behavior. */ 4488 { 4489 m_pNamedBufferData(immutable_buffer, sizeof(dummy_data) / 2, dummy_data, GL_DYNAMIC_COPY); 4490 4491 is_ok &= ErrorCheckAndLog("glNamedBufferData", GL_INVALID_OPERATION, 4492 " if the BUFFER_IMMUTABLE_STORAGE flag of the buffer object is TRUE."); 4493 } 4494 } 4495 catch (...) 4496 { 4497 is_ok = false; 4498 internal_error = true; 4499 } 4500 4501 if (buffer) 4502 { 4503 gl.deleteBuffers(1, &buffer); 4504 4505 buffer = 0; 4506 } 4507 4508 while (!too_much_buffers.empty()) 4509 { 4510 glw::GLuint tmp_buffer = too_much_buffers.top(); 4511 4512 if (tmp_buffer) 4513 { 4514 gl.deleteBuffers(1, &tmp_buffer); 4515 } 4516 4517 too_much_buffers.pop(); 4518 } 4519 4520 if (immutable_buffer) 4521 { 4522 gl.deleteBuffers(1, &immutable_buffer); 4523 4524 immutable_buffer = 0; 4525 } 4526 4527 if (internal_error) 4528 { 4529 throw 0; 4530 } 4531 4532 return is_ok; 4533 } 4534 4535 /** @brief Test Errors Of NamedBufferStorage function. 4536 * 4537 * Check that INVALID_OPERATION is generated by NamedBufferStorage if 4538 * buffer is not the name of an existing buffer object. 4539 * 4540 * Check that INVALID_VALUE is generated by NamedBufferStorage if size is 4541 * less than or equal to zero. 4542 * 4543 * Check that INVALID_VALUE is generated by NamedBufferStorage if flags has 4544 * any bits set other than DYNAMIC_STORAGE_BIT, MAP_READ_BIT, 4545 * MAP_WRITE_BIT, MAP_PERSISTENT_BIT, MAP_COHERENT_BIT or 4546 * CLIENT_STORAGE_BIT. 4547 * 4548 * Check that INVALID_VALUE error is generated by NamedBufferStorage if 4549 * flags contains MAP_PERSISTENT_BIT but does not contain at least one of 4550 * MAP_READ_BIT or MAP_WRITE_BIT. 4551 * 4552 * Check that INVALID_VALUE is generated by NamedBufferStorage if flags 4553 * contains MAP_COHERENT_BIT, but does not also contain MAP_PERSISTENT_BIT. 4554 * 4555 * True if test case succeeded, false otherwise. 4556 */ 4557 bool ErrorsTest::TestErrorsOfNamedBufferStorage() 4558 { 4559 /* Shortcut for GL functionality. */ 4560 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4561 4562 /* Return value. */ 4563 bool is_ok = true; 4564 bool internal_error = false; 4565 4566 /* Common variables. */ 4567 glw::GLuint buffer = 0; 4568 glw::GLubyte dummy_data[4] = {}; 4569 std::stack<glw::GLuint> too_much_buffers; 4570 4571 try 4572 { 4573 /* Test invalid buffer name error behavior. */ 4574 { 4575 /* Prepare for invalid buffer name error behavior verification. */ 4576 glw::GLuint not_a_buffer_name = 0; 4577 4578 while (gl.isBuffer(++not_a_buffer_name)) 4579 ; 4580 4581 /* Test. */ 4582 m_pNamedBufferStorage(not_a_buffer_name, sizeof(dummy_data), dummy_data, GL_MAP_WRITE_BIT); 4583 4584 is_ok &= ErrorCheckAndLog("glNamedBufferStorage", GL_INVALID_OPERATION, 4585 " if buffer is not the name of an existing buffer object."); 4586 } 4587 4588 /* Test negative or zero size error behavior. */ 4589 { 4590 /* Object creation. */ 4591 gl.createBuffers(1, &buffer); 4592 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4593 4594 /* Test negative size. */ 4595 m_pNamedBufferStorage(buffer, -1, dummy_data, GL_DYNAMIC_COPY); 4596 4597 is_ok &= ErrorCheckAndLog("glNamedBufferStorage", GL_INVALID_VALUE, " if size is negative."); 4598 4599 /* Test zero size. */ 4600 m_pNamedBufferStorage(buffer, 0, dummy_data, GL_DYNAMIC_COPY); 4601 4602 is_ok &= ErrorCheckAndLog("glNamedBufferStorage", GL_INVALID_VALUE, " if size zero."); 4603 4604 /* Clean-up. */ 4605 gl.deleteBuffers(1, &buffer); 4606 4607 buffer = 0; 4608 4609 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers failed."); 4610 } 4611 4612 /* Test invalid usage bit error behavior. */ 4613 { 4614 /* Prepare for invalid type error behavior verification. */ 4615 glw::GLuint valid_bits = GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | 4616 GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_CLIENT_STORAGE_BIT; 4617 4618 if (m_context.getContextInfo().isExtensionSupported("GL_ARB_sparse_buffer")) 4619 { 4620 valid_bits |= GL_SPARSE_STORAGE_BIT_ARB; 4621 } 4622 4623 if (m_context.getContextInfo().isExtensionSupported("GL_NV_gpu_multicast") || 4624 m_context.getContextInfo().isExtensionSupported("GL_NVX_linked_gpu_multicast")) 4625 { 4626 valid_bits |= GL_PER_GPU_STORAGE_BIT_NV; 4627 } 4628 4629 glw::GLuint invalid_bits = ~valid_bits; 4630 4631 glw::GLuint bits_count = CHAR_BIT * sizeof(invalid_bits); 4632 4633 /* Test. */ 4634 for (glw::GLuint i = 0; i < bits_count; ++i) 4635 { 4636 glw::GLuint possibly_invalid_bit = (1 << i); 4637 4638 if (invalid_bits & possibly_invalid_bit) 4639 { 4640 /* Object creation. */ 4641 gl.createBuffers(1, &buffer); 4642 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4643 4644 /* Test invalid bit. */ 4645 m_pNamedBufferStorage(buffer, sizeof(dummy_data), dummy_data, possibly_invalid_bit); 4646 4647 is_ok &= 4648 ErrorCheckAndLog("glNamedBufferStorage", GL_INVALID_VALUE, 4649 " if flags has any bits set other than DYNAMIC_STORAGE_BIT, MAP_READ_BIT," 4650 " MAP_WRITE_BIT, MAP_PERSISTENT_BIT, MAP_COHERENT_BIT or CLIENT_STORAGE_BIT."); 4651 4652 /* Release object. */ 4653 gl.deleteBuffers(1, &buffer); 4654 4655 buffer = 0; 4656 4657 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers failed."); 4658 } 4659 } 4660 } 4661 4662 /* Test improper persistent bit behavior error behavior. */ 4663 { 4664 /* Object creation. */ 4665 gl.createBuffers(1, &buffer); 4666 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4667 4668 /* Test. */ 4669 m_pNamedBufferStorage(buffer, sizeof(dummy_data), dummy_data, GL_MAP_PERSISTENT_BIT); 4670 4671 is_ok &= ErrorCheckAndLog("glNamedBufferStorage", GL_INVALID_VALUE, " if flags contains MAP_PERSISTENT_BIT " 4672 "but does not contain at least one of " 4673 "MAP_READ_BIT or MAP_WRITE_BIT."); 4674 4675 /* Clean-up. */ 4676 gl.deleteBuffers(1, &buffer); 4677 4678 buffer = 0; 4679 4680 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers failed."); 4681 } 4682 4683 /* Test improper persistent bit behavior error behavior. */ 4684 { 4685 /* Object creation. */ 4686 gl.createBuffers(1, &buffer); 4687 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4688 4689 /* Test. */ 4690 m_pNamedBufferStorage(buffer, sizeof(dummy_data), dummy_data, 4691 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_COHERENT_BIT); 4692 4693 is_ok &= 4694 ErrorCheckAndLog("glNamedBufferStorage", GL_INVALID_VALUE, 4695 " if flags contains MAP_COHERENT_BIT, but does not also contain MAP_PERSISTENT_BIT."); 4696 4697 /* Clean-up. */ 4698 gl.deleteBuffers(1, &buffer); 4699 4700 buffer = 0; 4701 4702 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers failed."); 4703 } 4704 } 4705 catch (...) 4706 { 4707 is_ok = false; 4708 internal_error = true; 4709 } 4710 4711 if (buffer) 4712 { 4713 gl.deleteBuffers(1, &buffer); 4714 4715 buffer = 0; 4716 } 4717 4718 while (!too_much_buffers.empty()) 4719 { 4720 glw::GLuint tmp_buffer = too_much_buffers.top(); 4721 4722 if (tmp_buffer) 4723 { 4724 gl.deleteBuffers(1, &tmp_buffer); 4725 } 4726 4727 too_much_buffers.pop(); 4728 } 4729 4730 if (internal_error) 4731 { 4732 throw 0; 4733 } 4734 4735 return is_ok; 4736 } 4737 4738 /** @brief Test Errors Of NamedBufferSubData function. 4739 * 4740 * Check that INVALID_OPERATION is generated by NamedBufferSubData if 4741 * buffer is not the name of an existing buffer object. 4742 * 4743 * Check that INVALID_VALUE is generated by NamedBufferSubData if offset or 4744 * size is negative, or if offset+size is greater than the value of 4745 * BUFFER_SIZE for the specified buffer object. 4746 * 4747 * Check that INVALID_OPERATION is generated by NamedBufferSubData if any 4748 * part of the specified range of the buffer object is mapped with 4749 * MapBufferRange or MapBuffer, unless it was mapped with the 4750 * MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags. 4751 * 4752 * Check that INVALID_OPERATION is generated by NamedBufferSubData if the 4753 * value of the BUFFER_IMMUTABLE_STORAGE flag of the buffer object is TRUE 4754 * and the value of BUFFER_STORAGE_FLAGS for the buffer object does not 4755 * have the DYNAMIC_STORAGE_BIT bit set. 4756 * 4757 * True if test case succeeded, false otherwise. 4758 */ 4759 bool ErrorsTest::TestErrorsOfNamedBufferSubData() 4760 { 4761 /* Shortcut for GL functionality. */ 4762 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4763 4764 /* Return value. */ 4765 bool is_ok = true; 4766 bool internal_error = false; 4767 4768 /* Common variables. */ 4769 glw::GLuint buffer = 0; 4770 glw::GLuint immutable_storage_buffer = 0; 4771 glw::GLubyte dummy_data[4] = {}; 4772 4773 try 4774 { 4775 /* Common preparations. */ 4776 gl.createBuffers(1, &buffer); 4777 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4778 4779 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, 4780 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_PERSISTENT_BIT); 4781 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 4782 4783 gl.createBuffers(1, &immutable_storage_buffer); 4784 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4785 4786 m_pNamedBufferStorage(immutable_storage_buffer, sizeof(dummy_data), &dummy_data, GL_MAP_READ_BIT); 4787 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 4788 4789 /* Test invalid buffer name error behavior. */ 4790 { 4791 /* Prepare for invalid buffer name error behavior verification. */ 4792 glw::GLuint not_a_buffer_name = 0; 4793 4794 while (gl.isBuffer(++not_a_buffer_name)) 4795 ; 4796 4797 /* Test. */ 4798 m_pNamedBufferSubData(not_a_buffer_name, 0, sizeof(dummy_data), &dummy_data); 4799 4800 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_INVALID_OPERATION, 4801 " if buffer is not the name of an existing buffer object."); 4802 } 4803 4804 /* Test negative offset error behavior. */ 4805 { 4806 /* Test. */ 4807 m_pNamedBufferSubData(buffer, -1, sizeof(dummy_data), &dummy_data); 4808 4809 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_INVALID_VALUE, " if offset or size is negative."); 4810 } 4811 4812 /* Test negative size error behavior. */ 4813 { 4814 /* Test. */ 4815 m_pNamedBufferSubData(buffer, 0, -1, &dummy_data); 4816 4817 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_INVALID_VALUE, " if offset or size is negative."); 4818 } 4819 4820 /* Test size overflow error behavior. */ 4821 { 4822 /* Test. */ 4823 m_pNamedBufferSubData(buffer, 0, sizeof(dummy_data) * 2, &dummy_data); 4824 4825 is_ok &= ErrorCheckAndLog( 4826 "glNamedBufferSubData", GL_INVALID_VALUE, 4827 " if offset+size is greater than the value of BUFFER_SIZE for the specified buffer object."); 4828 } 4829 4830 /* Test offset+size overflow error behavior. */ 4831 { 4832 /* Test. */ 4833 m_pNamedBufferSubData(buffer, sizeof(dummy_data) / 2, sizeof(dummy_data), &dummy_data); 4834 4835 is_ok &= ErrorCheckAndLog( 4836 "glNamedBufferSubData", GL_INVALID_VALUE, 4837 " if offset+size is greater than the value of BUFFER_SIZE for the specified buffer object."); 4838 } 4839 4840 /* Test of mapped buffer subdata error behavior verification (with glMapBuffer). */ 4841 { 4842 (void)(glw::GLbyte*) m_pMapNamedBuffer(buffer, GL_READ_ONLY); 4843 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 4844 4845 m_pNamedBufferSubData(buffer, 0, sizeof(dummy_data), &dummy_data); 4846 4847 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_INVALID_OPERATION, 4848 " if any part of the specified range of the buffer" 4849 " object is mapped with MapBuffer, unless it was mapped with " 4850 "the MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags."); 4851 4852 m_pUnmapNamedBuffer(buffer); 4853 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 4854 } 4855 4856 /* Test of mapped buffer subdata error behavior verification (with glMapBufferRange). */ 4857 { 4858 (void)(glw::GLbyte*) m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT); 4859 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 4860 4861 m_pNamedBufferSubData(buffer, 0, sizeof(dummy_data), &dummy_data); 4862 4863 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_INVALID_OPERATION, 4864 " if any part of the specified range of the buffer" 4865 " object is mapped with MapBufferRange, unless it was mapped with " 4866 "the MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags."); 4867 4868 m_pUnmapNamedBuffer(buffer); 4869 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 4870 } 4871 4872 /* Test of persistently mapped buffer clear error with behavior verification. */ 4873 { 4874 (void)(glw::GLbyte*) 4875 m_pMapNamedBufferRange(buffer, 0, sizeof(dummy_data), GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT); 4876 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapNamedBuffer failed."); 4877 4878 m_pNamedBufferSubData(buffer, 0, sizeof(dummy_data), &dummy_data); 4879 4880 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_NO_ERROR, 4881 " if any part of the specified range of the buffer" 4882 " object is mapped with MapBuffer with the MAP_PERSISTENT_BIT" 4883 " bit set in the MapBufferRange access flags."); 4884 4885 m_pUnmapNamedBuffer(buffer); 4886 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapNamedBuffer failed."); 4887 } 4888 4889 /* Test DYNAMIC_STORAGE_BIT bit off immutable buffer not set error behavior. */ 4890 { 4891 /* Test. */ 4892 m_pNamedBufferSubData(immutable_storage_buffer, 0, sizeof(dummy_data), &dummy_data); 4893 4894 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_INVALID_OPERATION, 4895 " if the value of the BUFFER_IMMUTABLE_STORAGE flag of the buffer object is TRUE" 4896 " and the value of BUFFER_STORAGE_FLAGS for the buffer object does not" 4897 " have the DYNAMIC_STORAGE_BIT bit set."); 4898 } 4899 4900 /* Test DYNAMIC_STORAGE_BIT bit off immutable buffer set no error behavior. */ 4901 { 4902 /* Test. */ 4903 m_pNamedBufferSubData(buffer, 0, sizeof(dummy_data), &dummy_data); 4904 4905 is_ok &= ErrorCheckAndLog("glNamedBufferSubData", GL_NO_ERROR, 4906 " if the value of the BUFFER_IMMUTABLE_STORAGE flag of the buffer object is TRUE" 4907 " and the value of BUFFER_STORAGE_FLAGS for the buffer object" 4908 " have the DYNAMIC_STORAGE_BIT bit set."); 4909 } 4910 } 4911 catch (...) 4912 { 4913 is_ok = false; 4914 internal_error = true; 4915 } 4916 4917 if (buffer) 4918 { 4919 gl.deleteBuffers(1, &buffer); 4920 4921 buffer = 0; 4922 } 4923 4924 if (immutable_storage_buffer) 4925 { 4926 gl.deleteBuffers(1, &immutable_storage_buffer); 4927 4928 buffer = 0; 4929 } 4930 4931 if (internal_error) 4932 { 4933 throw 0; 4934 } 4935 4936 return is_ok; 4937 } 4938 4939 /** @brief Test Errors Of UnmapNamedBuffer function. 4940 * 4941 * Check that INVALID_OPERATION is generated by UnmapNamedBuffer if buffer 4942 * is not the name of an existing buffer object. 4943 * 4944 * Check that INVALID_OPERATION is generated by UnmapNamedBuffer if the 4945 * buffer object is not in a mapped state. 4946 * 4947 * True if test case succeeded, false otherwise. 4948 */ 4949 bool ErrorsTest::TestErrorsOfUnmapNamedBuffer() 4950 { 4951 /* Shortcut for GL functionality. */ 4952 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 4953 4954 /* Return value. */ 4955 bool is_ok = true; 4956 bool internal_error = false; 4957 4958 /* Common variables. */ 4959 glw::GLuint buffer = 0; 4960 glw::GLubyte dummy_data[4] = {}; 4961 4962 try 4963 { 4964 /* Common preparations. */ 4965 gl.createBuffers(1, &buffer); 4966 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers failed."); 4967 4968 m_pNamedBufferStorage(buffer, sizeof(dummy_data), &dummy_data, 4969 GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_PERSISTENT_BIT); 4970 GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBuffeStorage failed."); 4971 4972 /* Test invalid buffer name error behavior. */ 4973 { 4974 /* Prepare for invalid buffer name error behavior verification. */ 4975 glw::GLuint not_a_buffer_name = 0; 4976 4977 while (gl.isBuffer(++not_a_buffer_name)) 4978 ; 4979 4980 /* Test. */ 4981 m_pUnmapNamedBuffer(not_a_buffer_name); 4982 4983 is_ok &= ErrorCheckAndLog("glUnmapNamedBuffer", GL_INVALID_OPERATION, 4984 " if buffer is not the name of an existing buffer object."); 4985 } 4986 4987 /* Test not mapped buffer error behavior verification. */ 4988 { 4989 m_pUnmapNamedBuffer(buffer); 4990 4991 is_ok &= ErrorCheckAndLog("glUnmapNamedBuffer", GL_INVALID_OPERATION, 4992 " if the buffer object is not in a mapped state."); 4993 } 4994 } 4995 catch (...) 4996 { 4997 is_ok = false; 4998 internal_error = true; 4999 } 5000 5001 if (buffer) 5002 { 5003 gl.deleteBuffers(1, &buffer); 5004 5005 buffer = 0; 5006 } 5007 5008 if (internal_error) 5009 { 5010 throw 0; 5011 } 5012 5013 return is_ok; 5014 } 5015 5016 /******************************** Functional Test Implementation ********************************/ 5017 5018 /** @brief Vertex shader source code */ 5019 const glw::GLchar FunctionalTest::s_vertex_shader[] = "#version 450\n" 5020 "\n" 5021 "in int data_in;\n" 5022 "out int data_out;\n" 5023 "\n" 5024 "void main()\n" 5025 "{\n" 5026 " gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n" 5027 "\n" 5028 " data_out = data_in * data_in;\n" 5029 "}\n"; 5030 5031 /** @brief Fragment shader source code */ 5032 const glw::GLchar FunctionalTest::s_fragment_shader[] = "#version 450\n" 5033 "\n" 5034 "out vec4 color;\n" 5035 "\n" 5036 "void main()\n" 5037 "{\n" 5038 " color = vec4(0.0);\n" 5039 "}\n"; 5040 5041 const glw::GLchar FunctionalTest::s_vertex_shader_input_name[] = 5042 "data_in"; //!< Vertex shader's name of the input attribute. 5043 5044 const glw::GLchar* FunctionalTest::s_vertex_shader_output_name = 5045 "data_out"; //!< Vertex shader's name of the transform feedback varying. 5046 5047 const glw::GLint FunctionalTest::s_initial_data_a[] = { 5048 1, 2, 3, 4, 5, 5 5049 }; //!< Initial data to be uploaded for the input buffer. 5050 5051 const glw::GLint FunctionalTest::s_initial_data_b[] = { 5052 0, 0, 0, 0, 0, 0, 36 5053 }; //!< Initial data to be uploaded for the output buffer. 5054 5055 const glw::GLint FunctionalTest::s_expected_data[] = { 5056 0, 1, 4, 9, 16, 25, 36 5057 }; //!< Expected result which shall be read from output buffer. 5058 5059 /** @brief Functional Test constructor. 5060 * 5061 * @param [in] context OpenGL context. 5062 */ 5063 FunctionalTest::FunctionalTest(deqp::Context& context) 5064 : deqp::TestCase(context, "buffers_functional", "Buffer Objects Functional Test") 5065 , m_pClearNamedBufferData(DE_NULL) 5066 , m_pClearNamedBufferSubData(DE_NULL) 5067 , m_pCopyNamedBufferSubData(DE_NULL) 5068 , m_pFlushMappedNamedBufferRange(DE_NULL) 5069 , m_pGetNamedBufferParameteri64v(DE_NULL) 5070 , m_pGetNamedBufferParameteriv(DE_NULL) 5071 , m_pGetNamedBufferPointerv(DE_NULL) 5072 , m_pGetNamedBufferSubData(DE_NULL) 5073 , m_pMapNamedBuffer(DE_NULL) 5074 , m_pMapNamedBufferRange(DE_NULL) 5075 , m_pNamedBufferData(DE_NULL) 5076 , m_pNamedBufferStorage(DE_NULL) 5077 , m_pNamedBufferSubData(DE_NULL) 5078 , m_pUnmapNamedBuffer(DE_NULL) 5079 , m_po(0) 5080 , m_vao(0) 5081 , m_bo_in(0) 5082 , m_bo_out(0) 5083 , m_attrib_location(-1) 5084 { 5085 /* Intentionally left blank. */ 5086 } 5087 5088 /** @brief Run Functional Test. 5089 * 5090 * @return Iteration result. 5091 */ 5092 tcu::TestNode::IterateResult FunctionalTest::iterate() 5093 { 5094 /* Shortcut for GL functionality. */ 5095 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5096 5097 /* Get context setup. */ 5098 bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5))); 5099 bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access"); 5100 5101 if ((!is_at_least_gl_45) && (!is_arb_direct_state_access)) 5102 { 5103 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported"); 5104 5105 return STOP; 5106 } 5107 5108 /* Running tests. */ 5109 bool is_ok = true; 5110 bool is_error = false; 5111 5112 /* API function pointers setup. */ 5113 m_pClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATA)gl.clearNamedBufferData; 5114 m_pClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATA)gl.clearNamedBufferSubData; 5115 m_pCopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATA)gl.copyNamedBufferSubData; 5116 m_pFlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE)gl.flushMappedNamedBufferRange; 5117 m_pGetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64V)gl.getNamedBufferParameteri64v; 5118 m_pGetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIV)gl.getNamedBufferParameteriv; 5119 m_pGetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERV)gl.getNamedBufferPointerv; 5120 m_pGetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATA)gl.getNamedBufferSubData; 5121 m_pMapNamedBuffer = (PFNGLMAPNAMEDBUFFER)gl.mapNamedBuffer; 5122 m_pMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGE)gl.mapNamedBufferRange; 5123 m_pNamedBufferData = (PFNGLNAMEDBUFFERDATA)gl.namedBufferData; 5124 m_pNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGE)gl.namedBufferStorage; 5125 m_pNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATA)gl.namedBufferSubData; 5126 m_pUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFER)gl.unmapNamedBuffer; 5127 5128 try 5129 { 5130 /* API function pointers check. */ 5131 if ((DE_NULL == m_pClearNamedBufferData) || (DE_NULL == m_pClearNamedBufferSubData) || 5132 (DE_NULL == m_pCopyNamedBufferSubData) || (DE_NULL == m_pFlushMappedNamedBufferRange) || 5133 (DE_NULL == m_pGetNamedBufferParameteri64v) || (DE_NULL == m_pGetNamedBufferParameteriv) || 5134 (DE_NULL == m_pGetNamedBufferPointerv) || (DE_NULL == m_pGetNamedBufferSubData) || 5135 (DE_NULL == m_pMapNamedBuffer) || (DE_NULL == m_pMapNamedBufferRange) || (DE_NULL == m_pNamedBufferData) || 5136 (DE_NULL == m_pNamedBufferStorage) || (DE_NULL == m_pNamedBufferSubData) || 5137 (DE_NULL == m_pUnmapNamedBuffer)) 5138 { 5139 throw 0; 5140 } 5141 5142 /* Running test. */ 5143 BuildProgram(); 5144 PrepareVertexArrayObject(); 5145 5146 is_ok = is_ok && PrepareInputBuffer(); 5147 is_ok = is_ok && PrepareOutputBuffer(); 5148 5149 if (is_ok) 5150 { 5151 Draw(); 5152 } 5153 5154 is_ok = is_ok && CheckArrayBufferImmutableFlag(); 5155 is_ok = is_ok && CheckTransformFeedbackBufferSize(); 5156 is_ok = is_ok && CheckTransformFeedbackResult(); 5157 } 5158 catch (...) 5159 { 5160 is_ok = false; 5161 is_error = true; 5162 } 5163 5164 /* Clean Up. */ 5165 Cleanup(); 5166 5167 /* Errors clean up. */ 5168 while (gl.getError()) 5169 ; 5170 5171 /* Result's setup. */ 5172 if (is_ok) 5173 { 5174 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 5175 } 5176 else 5177 { 5178 if (is_error) 5179 { 5180 m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error"); 5181 } 5182 else 5183 { 5184 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 5185 } 5186 } 5187 5188 return STOP; 5189 } 5190 5191 /** @brief Build test's GL program */ 5192 void FunctionalTest::BuildProgram() 5193 { 5194 /* Shortcut for GL functionality */ 5195 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5196 5197 struct Shader 5198 { 5199 glw::GLchar const* const source; 5200 glw::GLenum const type; 5201 glw::GLuint id; 5202 } shader[] = { { s_vertex_shader, GL_VERTEX_SHADER, 0 }, { s_fragment_shader, GL_FRAGMENT_SHADER, 0 } }; 5203 5204 glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]); 5205 5206 try 5207 { 5208 /* Create program. */ 5209 m_po = gl.createProgram(); 5210 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed."); 5211 5212 /* Shader compilation. */ 5213 5214 for (glw::GLuint i = 0; i < shader_count; ++i) 5215 { 5216 if (DE_NULL != shader[i].source) 5217 { 5218 shader[i].id = gl.createShader(shader[i].type); 5219 5220 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader call failed."); 5221 5222 gl.attachShader(m_po, shader[i].id); 5223 5224 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader call failed."); 5225 5226 gl.shaderSource(shader[i].id, 1, &(shader[i].source), NULL); 5227 5228 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource call failed."); 5229 5230 gl.compileShader(shader[i].id); 5231 5232 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader call failed."); 5233 5234 glw::GLint status = GL_FALSE; 5235 5236 gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status); 5237 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed."); 5238 5239 if (GL_FALSE == status) 5240 { 5241 glw::GLint log_size = 0; 5242 gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size); 5243 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed."); 5244 5245 glw::GLchar* log_text = new glw::GLchar[log_size]; 5246 5247 gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]); 5248 5249 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader compilation has failed.\n" 5250 << "Shader type: " << glu::getShaderTypeStr(shader[i].type) 5251 << "\n" 5252 << "Shader compilation error log:\n" 5253 << log_text << "\n" 5254 << "Shader source code:\n" 5255 << shader[i].source << "\n" 5256 << tcu::TestLog::EndMessage; 5257 5258 delete[] log_text; 5259 5260 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog call failed."); 5261 5262 throw 0; 5263 } 5264 } 5265 } 5266 5267 /* Tranform feedback varying */ 5268 gl.transformFeedbackVaryings(m_po, 1, &s_vertex_shader_output_name, GL_INTERLEAVED_ATTRIBS); 5269 GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings call failed."); 5270 5271 /* Link. */ 5272 gl.linkProgram(m_po); 5273 5274 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram call failed."); 5275 5276 glw::GLint status = GL_FALSE; 5277 5278 gl.getProgramiv(m_po, GL_LINK_STATUS, &status); 5279 5280 if (GL_TRUE == status) 5281 { 5282 for (glw::GLuint i = 0; i < shader_count; ++i) 5283 { 5284 if (shader[i].id) 5285 { 5286 gl.detachShader(m_po, shader[i].id); 5287 5288 GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed."); 5289 } 5290 } 5291 } 5292 else 5293 { 5294 glw::GLint log_size = 0; 5295 5296 gl.getProgramiv(m_po, GL_INFO_LOG_LENGTH, &log_size); 5297 5298 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv call failed."); 5299 5300 glw::GLchar* log_text = new glw::GLchar[log_size]; 5301 5302 gl.getProgramInfoLog(m_po, log_size, NULL, &log_text[0]); 5303 5304 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program linkage has failed due to:\n" 5305 << log_text << "\n" 5306 << tcu::TestLog::EndMessage; 5307 5308 delete[] log_text; 5309 5310 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog call failed."); 5311 5312 throw 0; 5313 } 5314 } 5315 catch (...) 5316 { 5317 if (m_po) 5318 { 5319 gl.deleteProgram(m_po); 5320 5321 m_po = 0; 5322 } 5323 } 5324 5325 for (glw::GLuint i = 0; i < shader_count; ++i) 5326 { 5327 if (0 != shader[i].id) 5328 { 5329 gl.deleteShader(shader[i].id); 5330 5331 shader[i].id = 0; 5332 } 5333 } 5334 5335 if (m_po) 5336 { 5337 gl.useProgram(m_po); 5338 GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed."); 5339 } 5340 5341 if (0 == m_po) 5342 { 5343 throw 0; 5344 } 5345 } 5346 5347 /** @brief Prepare empty vertex array object and bind it. */ 5348 void FunctionalTest::PrepareVertexArrayObject() 5349 { 5350 /* Shortcut for GL functionality */ 5351 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5352 5353 gl.genVertexArrays(1, &m_vao); 5354 GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed."); 5355 5356 gl.bindVertexArray(m_vao); 5357 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed."); 5358 } 5359 5360 /** Prepare input buffer in the way described in test specification (see class comment). */ 5361 bool FunctionalTest::PrepareInputBuffer() 5362 { 5363 /* Shortcut for GL functionality */ 5364 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5365 5366 /* Constants. */ 5367 static const glw::GLint zero = 0; 5368 static const glw::GLint one = 1; 5369 5370 /* Buffer preparation */ 5371 gl.createBuffers(1, &m_bo_in); 5372 5373 if (GL_NO_ERROR == gl.getError()) 5374 { 5375 /* Storage and last (6th) element preparation. */ 5376 m_pNamedBufferStorage(m_bo_in, sizeof(s_initial_data_a), s_initial_data_a, 5377 GL_MAP_WRITE_BIT | GL_DYNAMIC_STORAGE_BIT | GL_MAP_PERSISTENT_BIT); 5378 5379 if (GL_NO_ERROR == gl.getError()) 5380 { 5381 /* First element preparation. */ 5382 m_pClearNamedBufferSubData(m_bo_in, GL_R8, 0, sizeof(glw::GLint), GL_RED, GL_INT, &zero); 5383 5384 if (GL_NO_ERROR == gl.getError()) 5385 { 5386 /* Second element preparation. */ 5387 m_pNamedBufferSubData(m_bo_in, 1 /* 2nd element */ * sizeof(glw::GLint), sizeof(glw::GLint), &one); 5388 5389 if (GL_NO_ERROR == gl.getError()) 5390 { 5391 /* Third element preparation. */ 5392 glw::GLint* p = (glw::GLint*)m_pMapNamedBuffer(m_bo_in, GL_WRITE_ONLY); 5393 5394 if ((GL_NO_ERROR == gl.getError()) || (DE_NULL == p)) 5395 { 5396 p[2] = 2; 5397 5398 m_pUnmapNamedBuffer(m_bo_in); 5399 5400 if (GL_NO_ERROR == gl.getError()) 5401 { 5402 /* Fifth element preparation. */ 5403 m_pCopyNamedBufferSubData(m_bo_in, m_bo_in, sizeof(glw::GLint) * 3, sizeof(glw::GLint) * 4, 5404 sizeof(glw::GLint)); 5405 5406 if (GL_NO_ERROR == gl.getError()) 5407 { 5408 /* Fourth element preparation. */ 5409 p = (glw::GLint*)m_pMapNamedBufferRange( 5410 m_bo_in, sizeof(glw::GLint) * 3, sizeof(glw::GLint), 5411 GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_FLUSH_EXPLICIT_BIT); 5412 5413 if (GL_NO_ERROR == gl.getError()) 5414 { 5415 /* Write to mapped buffer. */ 5416 *p = 3; 5417 5418 /* Flush test. */ 5419 m_pFlushMappedNamedBufferRange(m_bo_in, 0, sizeof(glw::GLint)); 5420 5421 if (GL_NO_ERROR == gl.getError()) 5422 { 5423 /* Mapped Buffer Pointer query. */ 5424 glw::GLvoid* is_p = DE_NULL; 5425 m_pGetNamedBufferPointerv(m_bo_in, GL_BUFFER_MAP_POINTER, &is_p); 5426 5427 if (GL_NO_ERROR == gl.getError()) 5428 { 5429 /* Mapped Buffer pointer query check. */ 5430 if (p == is_p) 5431 { 5432 /* Unmapping. */ 5433 m_pUnmapNamedBuffer(m_bo_in); 5434 5435 if (GL_NO_ERROR == gl.getError()) 5436 { 5437 /* Setup buffer as input for vertex shader. */ 5438 m_attrib_location = 5439 gl.getAttribLocation(m_po, s_vertex_shader_input_name); 5440 GLU_EXPECT_NO_ERROR(gl.getError(), 5441 "glGetAttribLocation call failed."); 5442 5443 gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_in); 5444 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer call failed."); 5445 5446 gl.vertexAttribIPointer(m_attrib_location, 1, GL_INT, 0, NULL); 5447 GLU_EXPECT_NO_ERROR(gl.getError(), 5448 "glVertexAttribIPointer call failed."); 5449 5450 gl.enableVertexAttribArray(m_attrib_location); 5451 GLU_EXPECT_NO_ERROR(gl.getError(), 5452 "glEnableVertexAttribArray call failed."); 5453 5454 return true; 5455 } 5456 else 5457 { 5458 m_context.getTestContext().getLog() 5459 << tcu::TestLog::Message << "UnmapNamedBuffer has failed." 5460 << tcu::TestLog::EndMessage; 5461 } 5462 } 5463 else 5464 { 5465 m_pUnmapNamedBuffer(m_bo_in); 5466 m_context.getTestContext().getLog() 5467 << tcu::TestLog::Message 5468 << "Pointer returned by GetNamedBufferPointerv is not proper." 5469 << tcu::TestLog::EndMessage; 5470 } 5471 } 5472 else 5473 { 5474 m_pUnmapNamedBuffer(m_bo_in); 5475 m_context.getTestContext().getLog() << tcu::TestLog::Message 5476 << "GetNamedBufferPointerv has failed." 5477 << tcu::TestLog::EndMessage; 5478 } 5479 } 5480 else 5481 { 5482 m_pUnmapNamedBuffer(m_bo_in); 5483 m_context.getTestContext().getLog() << tcu::TestLog::Message 5484 << "FlushMappedNamedBufferRange has failed." 5485 << tcu::TestLog::EndMessage; 5486 } 5487 } 5488 else 5489 { 5490 m_context.getTestContext().getLog() << tcu::TestLog::Message 5491 << "MapNamedBufferRange has failed." 5492 << tcu::TestLog::EndMessage; 5493 } 5494 } 5495 else 5496 { 5497 m_context.getTestContext().getLog() << tcu::TestLog::Message 5498 << "CopyNamedBufferSubData has failed." 5499 << tcu::TestLog::EndMessage; 5500 } 5501 } 5502 else 5503 { 5504 m_context.getTestContext().getLog() 5505 << tcu::TestLog::Message << "UnmapNamedBuffer has failed." << tcu::TestLog::EndMessage; 5506 } 5507 } 5508 else 5509 { 5510 m_context.getTestContext().getLog() << tcu::TestLog::Message << "MapNamedBuffer has failed." 5511 << tcu::TestLog::EndMessage; 5512 } 5513 } 5514 else 5515 { 5516 m_context.getTestContext().getLog() << tcu::TestLog::Message << "NamedBufferSubData has failed." 5517 << tcu::TestLog::EndMessage; 5518 } 5519 } 5520 else 5521 { 5522 m_context.getTestContext().getLog() << tcu::TestLog::Message << "ClearNamedBufferSubData has failed." 5523 << tcu::TestLog::EndMessage; 5524 } 5525 } 5526 else 5527 { 5528 m_context.getTestContext().getLog() << tcu::TestLog::Message << "NamedBufferStorage has failed." 5529 << tcu::TestLog::EndMessage; 5530 } 5531 } 5532 else 5533 { 5534 m_context.getTestContext().getLog() << tcu::TestLog::Message << "CreateBuffers has failed." 5535 << tcu::TestLog::EndMessage; 5536 } 5537 5538 return false; 5539 } 5540 5541 /** Prepare output buffer in the way described in test specification (see class comment). */ 5542 bool FunctionalTest::PrepareOutputBuffer() 5543 { 5544 /* Shortcut for GL functionality */ 5545 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5546 5547 /* Buffer preparation */ 5548 gl.genBuffers(1, &m_bo_out); 5549 5550 if (GL_NO_ERROR == gl.getError()) 5551 { 5552 gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_out); 5553 5554 if (GL_NO_ERROR == gl.getError()) 5555 { 5556 m_pNamedBufferData(m_bo_out, sizeof(s_initial_data_b), s_initial_data_b, GL_DYNAMIC_COPY); 5557 5558 if (GL_NO_ERROR == gl.getError()) 5559 { 5560 gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_bo_out, 0, 5561 sizeof(s_initial_data_a) /* intentionally sizeof(a) < sizeof(b) */); 5562 5563 if (GL_NO_ERROR == gl.getError()) 5564 { 5565 return true; 5566 } 5567 else 5568 { 5569 m_context.getTestContext().getLog() << tcu::TestLog::Message << "BindBufferRange has failed." 5570 << tcu::TestLog::EndMessage; 5571 throw 0; /* This function is not being tested, throw test internal error */ 5572 } 5573 } 5574 else 5575 { 5576 m_context.getTestContext().getLog() << tcu::TestLog::Message << "NamedBufferData has failed." 5577 << tcu::TestLog::EndMessage; 5578 } 5579 } 5580 else 5581 { 5582 m_context.getTestContext().getLog() << tcu::TestLog::Message << "BindBuffer has failed." 5583 << tcu::TestLog::EndMessage; 5584 throw 0; /* This function is not being tested, throw test internal error */ 5585 } 5586 } 5587 else 5588 { 5589 m_context.getTestContext().getLog() << tcu::TestLog::Message << "GenBuffers has failed." 5590 << tcu::TestLog::EndMessage; 5591 throw 0; /* This function is not being tested, throw test internal error */ 5592 } 5593 5594 return false; 5595 } 5596 5597 /** Draw with the test program and transform feedback. */ 5598 void FunctionalTest::Draw() 5599 { 5600 /* Shortcut for GL functionality */ 5601 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5602 5603 /* Draw using transform feedback. */ 5604 gl.disable(GL_RASTERIZER_DISCARD); 5605 GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable call failed."); 5606 5607 gl.beginTransformFeedback(GL_POINTS); 5608 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback call failed."); 5609 5610 gl.drawArrays(GL_POINTS, 0, sizeof(s_initial_data_a) / sizeof(s_initial_data_a[0])); 5611 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed."); 5612 5613 gl.endTransformFeedback(); 5614 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback call failed."); 5615 5616 gl.enable(GL_RASTERIZER_DISCARD); 5617 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable call failed."); 5618 } 5619 5620 /** @brief Check that input buffer is immutable using GetNamedBufferParameteriv function. */ 5621 bool FunctionalTest::CheckArrayBufferImmutableFlag() 5622 { 5623 /* Shortcut for GL functionality. */ 5624 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5625 5626 /* Local query storage. */ 5627 glw::GLint is_storage_immutable = -1; 5628 5629 /* Querry. */ 5630 m_pGetNamedBufferParameteriv(m_bo_in, GL_BUFFER_IMMUTABLE_STORAGE, &is_storage_immutable); 5631 5632 /* Error checking. */ 5633 if (GL_NO_ERROR == gl.getError()) 5634 { 5635 /* Return value checking. */ 5636 if (-1 != is_storage_immutable) 5637 { 5638 /* Test. */ 5639 if (GL_TRUE == is_storage_immutable) 5640 { 5641 return true; 5642 } 5643 else 5644 { 5645 m_context.getTestContext().getLog() << tcu::TestLog::Message 5646 << "Input buffer storage is unexpectedly mutable." 5647 << tcu::TestLog::EndMessage; 5648 } 5649 } 5650 else 5651 { 5652 m_context.getTestContext().getLog() << tcu::TestLog::Message 5653 << "GetNamedBufferParameteriv has not returned a data." 5654 << tcu::TestLog::EndMessage; 5655 } 5656 } 5657 else 5658 { 5659 m_context.getTestContext().getLog() << tcu::TestLog::Message << "GetNamedBufferParameteriv has failed." 5660 << tcu::TestLog::EndMessage; 5661 } 5662 5663 return false; 5664 } 5665 5666 /** @brief Check that output buffer size using GetNamedBufferParameteri64v function. */ 5667 bool FunctionalTest::CheckTransformFeedbackBufferSize() 5668 { 5669 /* Shortcut for GL functionality. */ 5670 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5671 5672 /* Local query storage. */ 5673 glw::GLint64 size = -1; 5674 5675 /* Querry. */ 5676 m_pGetNamedBufferParameteri64v(m_bo_out, GL_BUFFER_SIZE, &size); 5677 5678 /* Error checking. */ 5679 if (GL_NO_ERROR == gl.getError()) 5680 { 5681 /* Return value checking. */ 5682 if (-1 != size) 5683 { 5684 /* Test. */ 5685 if (sizeof(s_initial_data_b) == size) 5686 { 5687 return true; 5688 } 5689 else 5690 { 5691 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Output buffer size is " << size 5692 << ", but " << sizeof(s_initial_data_b) << " was expected." 5693 << tcu::TestLog::EndMessage; 5694 } 5695 } 5696 else 5697 { 5698 m_context.getTestContext().getLog() << tcu::TestLog::Message 5699 << "GetNamedBufferParameteri64v has not returned a data." 5700 << tcu::TestLog::EndMessage; 5701 } 5702 } 5703 else 5704 { 5705 m_context.getTestContext().getLog() << tcu::TestLog::Message << "GetNamedBufferParameteri64v has failed." 5706 << tcu::TestLog::EndMessage; 5707 } 5708 5709 return false; 5710 } 5711 5712 /** @brief Check that results of the test are equal to the expected reference values. */ 5713 bool FunctionalTest::CheckTransformFeedbackResult() 5714 { 5715 /* Shortcut for GL functionality. */ 5716 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5717 5718 /* Local data storage. */ 5719 glw::GLint output_data[sizeof(s_initial_data_b) / sizeof(s_initial_data_b[0])] = {}; 5720 5721 /* Fetch data. */ 5722 m_pGetNamedBufferSubData(m_bo_out, 0, sizeof(output_data), output_data); 5723 5724 /* Error checking. */ 5725 if (GL_NO_ERROR == gl.getError()) 5726 { 5727 for (glw::GLuint i = 0; i < sizeof(s_initial_data_b) / sizeof(s_initial_data_b[0]); ++i) 5728 { 5729 if (s_expected_data[i] != output_data[i]) 5730 { 5731 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Expected data is not equal to results." 5732 << tcu::TestLog::EndMessage; 5733 return false; 5734 } 5735 } 5736 5737 return true; 5738 } 5739 else 5740 { 5741 m_context.getTestContext().getLog() << tcu::TestLog::Message << "GetNamedBufferSubData has failed." 5742 << tcu::TestLog::EndMessage; 5743 } 5744 return false; 5745 } 5746 5747 /** Clean all test's GL objects and state. */ 5748 void FunctionalTest::Cleanup() 5749 { 5750 /* Shortcut for GL functionality. */ 5751 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 5752 5753 /* Cleanup objects. */ 5754 if (m_po) 5755 { 5756 gl.useProgram(0); 5757 5758 gl.deleteProgram(m_po); 5759 5760 m_po = 0; 5761 } 5762 5763 if (m_vao) 5764 { 5765 gl.deleteVertexArrays(1, &m_vao); 5766 5767 m_vao = 0; 5768 } 5769 5770 if (0 <= m_attrib_location) 5771 { 5772 gl.disableVertexAttribArray(m_attrib_location); 5773 5774 m_attrib_location = -1; 5775 } 5776 5777 if (m_bo_in) 5778 { 5779 gl.deleteBuffers(1, &m_bo_in); 5780 5781 m_bo_in = 0; 5782 } 5783 5784 if (m_bo_out) 5785 { 5786 gl.deleteBuffers(1, &m_bo_out); 5787 5788 m_bo_out = 0; 5789 } 5790 5791 /* Make sure that rasterizer is turned on (default). */ 5792 gl.enable(GL_RASTERIZER_DISCARD); 5793 5794 /* Clean all errors. */ 5795 while (gl.getError()) 5796 ; 5797 } 5798 5799 } /* Buffers namespace. */ 5800 } /* DirectStateAccess namespace. */ 5801 } /* gl4cts namespace. */ 5802
