Import fixes from an internal repo.

* Fix buffer size requirement calculation
* Fix negative tests not checking relevant extensions

Change-Id: Ibc6759b6b4f0ef811a25eef88c4b5fe5964e9349

diff --git a/modules/gles3/functional/es3fNegativeBufferApiTests.cpp b/modules/gles3/functional/es3fNegativeBufferApiTests.cpp
index 827d872..2c0f716 100644 (file)
--- a/modules/gles3/functional/es3fNegativeBufferApiTests.cpp
+++ b/modules/gles3/functional/es3fNegativeBufferApiTests.cpp
@@ -1022,8 +1022,13 @@ void NegativeBufferApiTests::init (void)
                        m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
                        glRenderbufferStorage   (GL_RENDERBUFFER, -1, 1, 1);
                        expectError                             (GL_INVALID_ENUM);
-                       glRenderbufferStorage   (GL_RENDERBUFFER, GL_RGB16F, 1, 1);
-                       expectError                             (GL_INVALID_ENUM);
+
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
+                       {
+                               glRenderbufferStorage   (GL_RENDERBUFFER, GL_RGB16F, 1, 1);
+                               expectError                             (GL_INVALID_ENUM);
+                       }
+
                        glRenderbufferStorage   (GL_RENDERBUFFER, GL_RGBA8_SNORM, 1, 1);
                        expectError                             (GL_INVALID_ENUM);
                        m_log << TestLog::EndSection;
@@ -1350,8 +1355,13 @@ void NegativeBufferApiTests::init (void)
                        m_log << TestLog::Section("", "GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
                        glRenderbufferStorageMultisample        (GL_RENDERBUFFER, 2, -1, 1, 1);
                        expectError                                                     (GL_INVALID_ENUM);
-                       glRenderbufferStorageMultisample        (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1);
-                       expectError                                                     (GL_INVALID_ENUM);
+
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
+                       {
+                               glRenderbufferStorageMultisample        (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1);
+                               expectError                                                     (GL_INVALID_ENUM);
+                       }
+
                        glRenderbufferStorageMultisample        (GL_RENDERBUFFER, 2, GL_RGBA8_SNORM, 1, 1);
                        expectError                                                     (GL_INVALID_ENUM);
                        m_log << TestLog::EndSection;

diff --git a/modules/gles3/functional/es3fNegativeVertexArrayApiTests.cpp b/modules/gles3/functional/es3fNegativeVertexArrayApiTests.cpp
index f3dbb20..738d67b 100644 (file)
--- a/modules/gles3/functional/es3fNegativeVertexArrayApiTests.cpp
+++ b/modules/gles3/functional/es3fNegativeVertexArrayApiTests.cpp
@@ -376,34 +376,37 @@ void NegativeVertexArrayApiTests::init (void)
                        glDeleteFramebuffers(1, &fbo);
                        m_log << tcu::TestLog::EndSection;
 
-                       m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-                       const char* tfVarying           = "gl_Position";
-
-                       glGenBuffers                            (1, &buf);
-                       glGenTransformFeedbacks         (1, &tfID);
-
-                       glUseProgram                            (program.getProgram());
-                       glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-                       glLinkProgram                           (program.getProgram());
-                       glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
-                       glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-                       glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-                       glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-                       glBeginTransformFeedback        (GL_POINTS);
-                       expectError                                     (GL_NO_ERROR);
-
-                       glDrawElements                          (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_INVALID_OPERATION);
-
-                       glPauseTransformFeedback();
-                       glDrawElements                          (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_NO_ERROR);
-
-                       glEndTransformFeedback          ();
-                       glDeleteBuffers                         (1, &buf);
-                       glDeleteTransformFeedbacks      (1, &tfID);
-                       expectError                                     (GL_NO_ERROR);
-                       m_log << tcu::TestLog::EndSection;
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+                       {
+                               m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+                               const char* tfVarying           = "gl_Position";
+
+                               glGenBuffers                            (1, &buf);
+                               glGenTransformFeedbacks         (1, &tfID);
+
+                               glUseProgram                            (program.getProgram());
+                               glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+                               glLinkProgram                           (program.getProgram());
+                               glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
+                               glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+                               glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+                               glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+                               glBeginTransformFeedback        (GL_POINTS);
+                               expectError                                     (GL_NO_ERROR);
+
+                               glDrawElements                          (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_INVALID_OPERATION);
+
+                               glPauseTransformFeedback();
+                               glDrawElements                          (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_NO_ERROR);
+
+                               glEndTransformFeedback          ();
+                               glDeleteBuffers                         (1, &buf);
+                               glDeleteTransformFeedbacks      (1, &tfID);
+                               expectError                                     (GL_NO_ERROR);
+                               m_log << tcu::TestLog::EndSection;
+                       }
 
                        glUseProgram(0);
                });
@@ -476,34 +479,37 @@ void NegativeVertexArrayApiTests::init (void)
                        glDeleteFramebuffers(1, &fbo);
                        m_log << tcu::TestLog::EndSection;
 
-                       m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-                       const char* tfVarying           = "gl_Position";
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+                       {
+                               m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+                               const char* tfVarying           = "gl_Position";
 
-                       glGenBuffers                            (1, &buf);
-                       glGenTransformFeedbacks         (1, &tfID);
+                               glGenBuffers                            (1, &buf);
+                               glGenTransformFeedbacks         (1, &tfID);
 
-                       glUseProgram                            (program.getProgram());
-                       glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-                       glLinkProgram                           (program.getProgram());
-                       glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
-                       glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-                       glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-                       glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-                       glBeginTransformFeedback        (GL_TRIANGLES);
-                       expectError                                     (GL_NO_ERROR);
+                               glUseProgram                            (program.getProgram());
+                               glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+                               glLinkProgram                           (program.getProgram());
+                               glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
+                               glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+                               glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+                               glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+                               glBeginTransformFeedback        (GL_TRIANGLES);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glDrawElements                          (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_INVALID_OPERATION);
+                               glDrawElements                          (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_INVALID_OPERATION);
 
-                       glPauseTransformFeedback();
-                       glDrawElements                          (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_NO_ERROR);
+                               glPauseTransformFeedback();
+                               glDrawElements                          (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glEndTransformFeedback          ();
-                       glDeleteBuffers                         (1, &buf);
-                       glDeleteTransformFeedbacks      (1, &tfID);
-                       expectError                                     (GL_NO_ERROR);
-                       m_log << tcu::TestLog::EndSection;
+                               glEndTransformFeedback          ();
+                               glDeleteBuffers                         (1, &buf);
+                               glDeleteTransformFeedbacks      (1, &tfID);
+                               expectError                                     (GL_NO_ERROR);
+                               m_log << tcu::TestLog::EndSection;
+                       }
 
                        glUseProgram(0);
                });
@@ -640,34 +646,37 @@ void NegativeVertexArrayApiTests::init (void)
                        glDeleteFramebuffers(1, &fbo);
                        m_log << tcu::TestLog::EndSection;
 
-                       m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-                       const char* tfVarying           = "gl_Position";
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+                       {
+                               m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+                               const char* tfVarying           = "gl_Position";
 
-                       glGenBuffers                            (1, &buf);
-                       glGenTransformFeedbacks         (1, &tfID);
+                               glGenBuffers                            (1, &buf);
+                               glGenTransformFeedbacks         (1, &tfID);
 
-                       glUseProgram                            (program.getProgram());
-                       glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-                       glLinkProgram                           (program.getProgram());
-                       glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
-                       glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-                       glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-                       glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-                       glBeginTransformFeedback        (GL_POINTS);
-                       expectError                                     (GL_NO_ERROR);
+                               glUseProgram                            (program.getProgram());
+                               glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+                               glLinkProgram                           (program.getProgram());
+                               glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
+                               glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+                               glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+                               glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+                               glBeginTransformFeedback        (GL_POINTS);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glDrawElementsInstanced         (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
-                       expectError                                     (GL_INVALID_OPERATION);
+                               glDrawElementsInstanced         (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
+                               expectError                                     (GL_INVALID_OPERATION);
 
-                       glPauseTransformFeedback();
-                       glDrawElementsInstanced         (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
-                       expectError                                     (GL_NO_ERROR);
+                               glPauseTransformFeedback();
+                               glDrawElementsInstanced         (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glEndTransformFeedback          ();
-                       glDeleteBuffers                         (1, &buf);
-                       glDeleteTransformFeedbacks      (1, &tfID);
-                       expectError                                     (GL_NO_ERROR);
-                       m_log << tcu::TestLog::EndSection;
+                               glEndTransformFeedback          ();
+                               glDeleteBuffers                         (1, &buf);
+                               glDeleteTransformFeedbacks      (1, &tfID);
+                               expectError                                     (GL_NO_ERROR);
+                               m_log << tcu::TestLog::EndSection;
+                       }
 
                        glUseProgram(0);
                });
@@ -748,34 +757,37 @@ void NegativeVertexArrayApiTests::init (void)
                        glDeleteFramebuffers(1, &fbo);
                        m_log << tcu::TestLog::EndSection;
 
-                       m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-                       const char* tfVarying           = "gl_Position";
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+                       {
+                               m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+                               const char* tfVarying           = "gl_Position";
 
-                       glGenBuffers                            (1, &buf);
-                       glGenTransformFeedbacks         (1, &tfID);
+                               glGenBuffers                            (1, &buf);
+                               glGenTransformFeedbacks         (1, &tfID);
 
-                       glUseProgram                            (program.getProgram());
-                       glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-                       glLinkProgram                           (program.getProgram());
-                       glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
-                       glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-                       glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-                       glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-                       glBeginTransformFeedback        (GL_TRIANGLES);
-                       expectError                                     (GL_NO_ERROR);
+                               glUseProgram                            (program.getProgram());
+                               glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+                               glLinkProgram                           (program.getProgram());
+                               glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
+                               glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+                               glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+                               glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+                               glBeginTransformFeedback        (GL_TRIANGLES);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glDrawElementsInstanced         (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
-                       expectError                                     (GL_INVALID_OPERATION);
+                               glDrawElementsInstanced         (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
+                               expectError                                     (GL_INVALID_OPERATION);
 
-                       glPauseTransformFeedback();
-                       glDrawElementsInstanced         (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
-                       expectError                                     (GL_NO_ERROR);
+                               glPauseTransformFeedback();
+                               glDrawElementsInstanced         (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glEndTransformFeedback          ();
-                       glDeleteBuffers                         (1, &buf);
-                       glDeleteTransformFeedbacks      (1, &tfID);
-                       expectError                                     (GL_NO_ERROR);
-                       m_log << tcu::TestLog::EndSection;
+                               glEndTransformFeedback          ();
+                               glDeleteBuffers                         (1, &buf);
+                               glDeleteTransformFeedbacks      (1, &tfID);
+                               expectError                                     (GL_NO_ERROR);
+                               m_log << tcu::TestLog::EndSection;
+                       }
 
                        glUseProgram(0);
                });
@@ -820,34 +832,37 @@ void NegativeVertexArrayApiTests::init (void)
                        glDeleteFramebuffers(1, &fbo);
                        m_log << tcu::TestLog::EndSection;
 
-                       m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-                       const char* tfVarying           = "gl_Position";
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+                       {
+                               m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+                               const char* tfVarying           = "gl_Position";
 
-                       glGenBuffers                            (1, &buf);
-                       glGenTransformFeedbacks         (1, &tfID);
+                               glGenBuffers                            (1, &buf);
+                               glGenTransformFeedbacks         (1, &tfID);
 
-                       glUseProgram                            (program.getProgram());
-                       glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-                       glLinkProgram                           (program.getProgram());
-                       glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
-                       glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-                       glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-                       glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-                       glBeginTransformFeedback        (GL_POINTS);
-                       expectError                                     (GL_NO_ERROR);
+                               glUseProgram                            (program.getProgram());
+                               glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+                               glLinkProgram                           (program.getProgram());
+                               glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
+                               glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+                               glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+                               glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+                               glBeginTransformFeedback        (GL_POINTS);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glDrawRangeElements                     (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_INVALID_OPERATION);
+                               glDrawRangeElements                     (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_INVALID_OPERATION);
 
-                       glPauseTransformFeedback();
-                       glDrawRangeElements                     (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_NO_ERROR);
+                               glPauseTransformFeedback();
+                               glDrawRangeElements                     (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_NO_ERROR);
 
-                       glEndTransformFeedback          ();
-                       glDeleteBuffers                         (1, &buf);
-                       glDeleteTransformFeedbacks      (1, &tfID);
-                       expectError                                     (GL_NO_ERROR);
-                       m_log << tcu::TestLog::EndSection;
+                               glEndTransformFeedback          ();
+                               glDeleteBuffers                         (1, &buf);
+                               glDeleteTransformFeedbacks      (1, &tfID);
+                               expectError                                     (GL_NO_ERROR);
+                               m_log << tcu::TestLog::EndSection;
+                       }
 
                        glUseProgram(0);
                });
@@ -930,34 +945,37 @@ void NegativeVertexArrayApiTests::init (void)
                        glDeleteFramebuffers(1, &fbo);
                        m_log << tcu::TestLog::EndSection;
 
-                       m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-                       const char* tfVarying           = "gl_Position";
-
-                       glGenBuffers                            (1, &buf);
-                       glGenTransformFeedbacks         (1, &tfID);
-
-                       glUseProgram                            (program.getProgram());
-                       glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-                       glLinkProgram                           (program.getProgram());
-                       glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
-                       glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-                       glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-                       glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-                       glBeginTransformFeedback        (GL_TRIANGLES);
-                       expectError                                     (GL_NO_ERROR);
-
-                       glDrawRangeElements                     (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_INVALID_OPERATION);
-
-                       glPauseTransformFeedback();
-                       glDrawRangeElements                     (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-                       expectError                                     (GL_NO_ERROR);
-
-                       glEndTransformFeedback          ();
-                       glDeleteBuffers                         (1, &buf);
-                       glDeleteTransformFeedbacks      (1, &tfID);
-                       expectError                                     (GL_NO_ERROR);
-                       m_log << tcu::TestLog::EndSection;
+                       if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+                       {
+                               m_log << tcu::TestLog::Section("", "GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+                               const char* tfVarying           = "gl_Position";
+
+                               glGenBuffers                            (1, &buf);
+                               glGenTransformFeedbacks         (1, &tfID);
+
+                               glUseProgram                            (program.getProgram());
+                               glTransformFeedbackVaryings     (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+                               glLinkProgram                           (program.getProgram());
+                               glBindTransformFeedback         (GL_TRANSFORM_FEEDBACK, tfID);
+                               glBindBuffer                            (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+                               glBufferData                            (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+                               glBindBufferBase                        (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+                               glBeginTransformFeedback        (GL_TRIANGLES);
+                               expectError                                     (GL_NO_ERROR);
+
+                               glDrawRangeElements                     (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_INVALID_OPERATION);
+
+                               glPauseTransformFeedback();
+                               glDrawRangeElements                     (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+                               expectError                                     (GL_NO_ERROR);
+
+                               glEndTransformFeedback          ();
+                               glDeleteBuffers                         (1, &buf);
+                               glDeleteTransformFeedbacks      (1, &tfID);
+                               expectError                                     (GL_NO_ERROR);
+                               m_log << tcu::TestLog::EndSection;
+                       }
 
                        glUseProgram(0);
                });

diff --git a/modules/gles31/functional/es31fDebugTests.cpp b/modules/gles31/functional/es31fDebugTests.cpp
index 078197e..de288d4 100644 (file)
--- a/modules/gles31/functional/es31fDebugTests.cpp
+++ b/modules/gles31/functional/es31fDebugTests.cpp
@@ -575,7 +575,7 @@ CallbackErrorCase::IterateResult CallbackErrorCase::iterate (void)
 
        const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
        tcu::TestLog&                   log             = m_testCtx.getLog();
-       NegativeTestContext             context = NegativeTestContext(*this, m_context.getRenderContext(), log, m_results, true);
+       NegativeTestContext             context = NegativeTestContext(*this, m_context.getRenderContext(), m_context.getContextInfo(), log, m_results, true);
 
        gl.enable(GL_DEBUG_OUTPUT);
        gl.enable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -640,7 +640,7 @@ LogErrorCase::IterateResult LogErrorCase::iterate (void)
 
        const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
        tcu::TestLog&                   log             = m_testCtx.getLog();
-       NegativeTestContext             context = NegativeTestContext(*this, m_context.getRenderContext(), log, m_results, true);
+       NegativeTestContext             context = NegativeTestContext(*this, m_context.getRenderContext(), m_context.getContextInfo(), log, m_results, true);
        GLint                                   numMsg  = 0;
 
        gl.enable(GL_DEBUG_OUTPUT);
@@ -741,7 +741,7 @@ GetErrorCase::GetErrorCase (Context&        ctx,
 GetErrorCase::IterateResult GetErrorCase::iterate (void)
 {
        tcu::TestLog&                   log             = m_testCtx.getLog();
-       NegativeTestContext             context = NegativeTestContext(*this, m_context.getRenderContext(), log, m_results, true);
+       NegativeTestContext             context = NegativeTestContext(*this, m_context.getRenderContext(), m_context.getContextInfo(), log, m_results, true);
 
        m_errorFunc(context);
 
@@ -887,7 +887,7 @@ void FilterCase::callback (GLenum source, GLenum type, GLuint id, GLenum severit
 vector<MessageData> FilterCase::genMessages (bool uselog, const string& desc)
 {
        tcu::TestLog&                   log                     = m_testCtx.getLog();
-       NegativeTestContext             context         = NegativeTestContext(*this, m_context.getRenderContext(), log, m_results, uselog);
+       NegativeTestContext             context         = NegativeTestContext(*this, m_context.getRenderContext(), m_context.getContextInfo(), log, m_results, uselog);
        tcu::ScopedLogSection   section         (log, "message gen", desc);
        vector<MessageData>             messages;
 
@@ -1354,7 +1354,7 @@ AsyncCase::IterateResult AsyncCase::iterate (void)
 
        const glw::Functions& gl = m_context.getRenderContext().getFunctions();
        tcu::TestLog&           log                     = m_testCtx.getLog();
-       NegativeTestContext     context         = NegativeTestContext(*this, m_context.getRenderContext(), log, m_results, true);
+       NegativeTestContext     context         = NegativeTestContext(*this, m_context.getRenderContext(), m_context.getContextInfo(), log, m_results, true);
        const int                       maxWait         = 10000; // ms
        const int                       warnWait        = 100;
 

diff --git a/modules/gles31/functional/es31fDrawTests.cpp b/modules/gles31/functional/es31fDrawTests.cpp
index f0265e2..5bd9ccc 100644 (file)
--- a/modules/gles31/functional/es31fDrawTests.cpp
+++ b/modules/gles31/functional/es31fDrawTests.cpp
@@ -1076,16 +1076,18 @@ void ComputeShaderGeneratedCase::init (void)
 
        // check the SSBO buffers are of legal size
        {
-               const int       commandBufferSize       = m_commandSize * m_numDrawCmds;
-               deInt64         maxSSBOSize                     = 0;
+               const deUint64  drawBufferElementSize   = sizeof(tcu::Vec4);
+               const deUint64  indexBufferElementSize  = sizeof(deUint32);
+               const int               commandBufferSize               = m_commandSize * m_numDrawCmds;
+               deInt64                 maxSSBOSize                             = 0;
 
                gl.getInteger64v(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &maxSSBOSize);
 
-               if (m_computeData && (deInt64)calcDrawBufferSize() > maxSSBOSize)
+               if (m_computeData && (deUint64)calcDrawBufferSize()*drawBufferElementSize > (deUint64)maxSSBOSize)
                        throw tcu::NotSupportedError("GL_MAX_SHADER_STORAGE_BLOCK_SIZE is too small for vertex attrib buffers");
-               if (m_computeIndices && (deInt64)calcIndexBufferSize() > maxSSBOSize)
+               if (m_computeIndices && (deUint64)calcIndexBufferSize()*indexBufferElementSize > (deUint64)maxSSBOSize)
                        throw tcu::NotSupportedError("GL_MAX_SHADER_STORAGE_BLOCK_SIZE is too small for index buffers");
-               if (m_computeCmd && (deInt64)commandBufferSize > maxSSBOSize)
+               if (m_computeCmd && (deUint64)commandBufferSize > (deUint64)maxSSBOSize)
                        throw tcu::NotSupportedError("GL_MAX_SHADER_STORAGE_BLOCK_SIZE is too small for command buffers");
        }
 }

diff --git a/modules/gles31/functional/es31fNegativeBufferApiTests.cpp b/modules/gles31/functional/es31fNegativeBufferApiTests.cpp
index 6e723c8..3b4b4c8 100644 (file)
--- a/modules/gles31/functional/es31fNegativeBufferApiTests.cpp
+++ b/modules/gles31/functional/es31fNegativeBufferApiTests.cpp
@@ -24,6 +24,7 @@
 #include "es31fNegativeBufferApiTests.hpp"
 
 #include "gluCallLogWrapper.hpp"
+#include "gluContextInfo.hpp"
 
 #include "glwDefs.hpp"
 #include "glwEnums.hpp"
@@ -1046,8 +1047,13 @@ void renderbuffer_storage (NegativeTestContext& ctx)
        ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
        ctx.glRenderbufferStorage       (GL_RENDERBUFFER, -1, 1, 1);
        ctx.expectError                         (GL_INVALID_ENUM);
-       ctx.glRenderbufferStorage       (GL_RENDERBUFFER, GL_RGB16F, 1, 1);
-       ctx.expectError                         (GL_INVALID_ENUM);
+
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
+       {
+               ctx.glRenderbufferStorage       (GL_RENDERBUFFER, GL_RGB16F, 1, 1);
+               ctx.expectError                         (GL_INVALID_ENUM);
+       }
+
        ctx.glRenderbufferStorage       (GL_RENDERBUFFER, GL_RGBA8_SNORM, 1, 1);
        ctx.expectError                         (GL_INVALID_ENUM);
        ctx.endSection();
@@ -1380,8 +1386,13 @@ void renderbuffer_storage_multisample (NegativeTestContext& ctx)
        ctx.beginSection("GL_INVALID_ENUM is generated if internalformat is not a color-renderable, depth-renderable, or stencil-renderable format.");
        ctx.glRenderbufferStorageMultisample    (GL_RENDERBUFFER, 2, -1, 1, 1);
        ctx.expectError                                                 (GL_INVALID_ENUM);
-       ctx.glRenderbufferStorageMultisample    (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1);
-       ctx.expectError                                                 (GL_INVALID_ENUM);
+
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_half_float")) // GL_EXT_color_buffer_half_float disables error
+       {
+               ctx.glRenderbufferStorageMultisample    (GL_RENDERBUFFER, 2, GL_RGB16F, 1, 1);
+               ctx.expectError                                                 (GL_INVALID_ENUM);
+       }
+
        ctx.glRenderbufferStorageMultisample    (GL_RENDERBUFFER, 2, GL_RGBA8_SNORM, 1, 1);
        ctx.expectError                                                 (GL_INVALID_ENUM);
        ctx.endSection();

diff --git a/modules/gles31/functional/es31fNegativeTestShared.cpp b/modules/gles31/functional/es31fNegativeTestShared.cpp
index 74bc55b..7da1805 100644 (file)
--- a/modules/gles31/functional/es31fNegativeTestShared.cpp
+++ b/modules/gles31/functional/es31fNegativeTestShared.cpp
@@ -44,13 +44,15 @@ ErrorCase::ErrorCase (Context& ctx, const char* name, const char* desc)
 {
 }
 
-NegativeTestContext::NegativeTestContext (ErrorCase&                   host,
-                                                                                 glu::RenderContext&   renderCtx,
-                                                                                 tcu::TestLog&                 log,
-                                                                                 tcu::ResultCollector& results,
-                                                                                 bool                                  enableLogging_)
+NegativeTestContext::NegativeTestContext (ErrorCase&                           host,
+                                                                                 glu::RenderContext&           renderCtx,
+                                                                                 const glu::ContextInfo&       ctxInfo,
+                                                                                 tcu::TestLog&                         log,
+                                                                                 tcu::ResultCollector&         results,
+                                                                                 bool                                          enableLogging_)
        : glu::CallLogWrapper   (renderCtx.getFunctions(), log)
        , m_renderCtx                   (renderCtx)
+       , m_ctxInfo                             (ctxInfo)
        , m_host                                (host)
        , m_results                             (results)
        , m_openSections                (0)

diff --git a/modules/gles31/functional/es31fNegativeTestShared.hpp b/modules/gles31/functional/es31fNegativeTestShared.hpp
index e4eba1f..6e276aa 100644 (file)
--- a/modules/gles31/functional/es31fNegativeTestShared.hpp
+++ b/modules/gles31/functional/es31fNegativeTestShared.hpp
@@ -50,7 +50,7 @@ public:
 class NegativeTestContext : public glu::CallLogWrapper
 {
 public:
-                                                               NegativeTestContext             (ErrorCase& host, glu::RenderContext& renderCtx, tcu::TestLog& log,  tcu::ResultCollector& results, bool enableLog);
+                                                               NegativeTestContext             (ErrorCase& host, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, tcu::TestLog& log, tcu::ResultCollector& results, bool enableLog);
                                                                ~NegativeTestContext    ();
 
        const tcu::ResultCollector&     getResults                              (void) const;
@@ -58,6 +58,7 @@ public:
        void                                            fail                                    (const std::string& msg);
        int                                                     getInteger                              (glw::GLenum pname) const;
        const glu::RenderContext&       getRenderContext                (void) const { return m_renderCtx; }
+       const glu::ContextInfo&         getContextInfo                  (void) const { return m_ctxInfo; }
        void                                            beginSection                    (const std::string& desc);
        void                                            endSection                              (void);
 
@@ -67,6 +68,7 @@ public:
 
 private:
        glu::RenderContext&                     m_renderCtx;
+       const glu::ContextInfo&         m_ctxInfo;
        ErrorCase&                                      m_host;
        tcu::ResultCollector&           m_results;
        int                                                     m_openSections;

diff --git a/modules/gles31/functional/es31fNegativeVertexArrayApiTests.cpp b/modules/gles31/functional/es31fNegativeVertexArrayApiTests.cpp
index 35c401b..a7f50c2 100644 (file)
--- a/modules/gles31/functional/es31fNegativeVertexArrayApiTests.cpp
+++ b/modules/gles31/functional/es31fNegativeVertexArrayApiTests.cpp
@@ -24,6 +24,7 @@
 #include "es31fNegativeVertexArrayApiTests.hpp"
 
 #include "gluCallLogWrapper.hpp"
+#include "gluContextInfo.hpp"
 #include "gluShaderProgram.hpp"
 
 #include "glwDefs.hpp"
@@ -381,34 +382,37 @@ void draw_elements (NegativeTestContext& ctx)
        ctx.glDeleteFramebuffers(1, &fbo);
        ctx.endSection();
 
-       ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-       const char* tfVarying           = "gl_Position";
-
-       ctx.glGenBuffers                                (1, &buf);
-       ctx.glGenTransformFeedbacks             (1, &tfID);
-
-       ctx.glUseProgram                                (program.getProgram());
-       ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-       ctx.glLinkProgram                               (program.getProgram());
-       ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
-       ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-       ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-       ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-       ctx.glBeginTransformFeedback    (GL_POINTS);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glDrawElements                              (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_INVALID_OPERATION);
-
-       ctx.glPauseTransformFeedback();
-       ctx.glDrawElements                              (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glEndTransformFeedback              ();
-       ctx.glDeleteBuffers                             (1, &buf);
-       ctx.glDeleteTransformFeedbacks  (1, &tfID);
-       ctx.expectError                         (GL_NO_ERROR);
-       ctx.endSection();
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+       {
+               ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+               const char* tfVarying           = "gl_Position";
+
+               ctx.glGenBuffers                                (1, &buf);
+               ctx.glGenTransformFeedbacks             (1, &tfID);
+
+               ctx.glUseProgram                                (program.getProgram());
+               ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+               ctx.glLinkProgram                               (program.getProgram());
+               ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
+               ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+               ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+               ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+               ctx.glBeginTransformFeedback    (GL_POINTS);
+               ctx.expectError                         (GL_NO_ERROR);
+
+               ctx.glDrawElements                              (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                         (GL_INVALID_OPERATION);
+
+               ctx.glPauseTransformFeedback();
+               ctx.glDrawElements                              (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                         (GL_NO_ERROR);
+
+               ctx.glEndTransformFeedback              ();
+               ctx.glDeleteBuffers                             (1, &buf);
+               ctx.glDeleteTransformFeedbacks  (1, &tfID);
+               ctx.expectError                         (GL_NO_ERROR);
+               ctx.endSection();
+       }
 
        ctx.glUseProgram(0);
 }
@@ -483,34 +487,37 @@ void draw_elements_incomplete_primitive (NegativeTestContext& ctx)
        ctx.glDeleteFramebuffers(1, &fbo);
        ctx.endSection();
 
-       ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-       const char* tfVarying           = "gl_Position";
-
-       ctx.glGenBuffers                                (1, &buf);
-       ctx.glGenTransformFeedbacks             (1, &tfID);
-
-       ctx.glUseProgram                                (program.getProgram());
-       ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-       ctx.glLinkProgram                               (program.getProgram());
-       ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
-       ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-       ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-       ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-       ctx.glBeginTransformFeedback    (GL_TRIANGLES);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glDrawElements                              (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_INVALID_OPERATION);
-
-       ctx.glPauseTransformFeedback();
-       ctx.glDrawElements                              (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glEndTransformFeedback              ();
-       ctx.glDeleteBuffers                             (1, &buf);
-       ctx.glDeleteTransformFeedbacks  (1, &tfID);
-       ctx.expectError                         (GL_NO_ERROR);
-       ctx.endSection();
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+       {
+               ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+               const char* tfVarying           = "gl_Position";
+
+               ctx.glGenBuffers                                (1, &buf);
+               ctx.glGenTransformFeedbacks             (1, &tfID);
+
+               ctx.glUseProgram                                (program.getProgram());
+               ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+               ctx.glLinkProgram                               (program.getProgram());
+               ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
+               ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+               ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+               ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+               ctx.glBeginTransformFeedback    (GL_TRIANGLES);
+               ctx.expectError                                 (GL_NO_ERROR);
+
+               ctx.glDrawElements                              (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                                 (GL_INVALID_OPERATION);
+
+               ctx.glPauseTransformFeedback    ();
+               ctx.glDrawElements                              (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                                 (GL_NO_ERROR);
+
+               ctx.glEndTransformFeedback              ();
+               ctx.glDeleteBuffers                             (1, &buf);
+               ctx.glDeleteTransformFeedbacks  (1, &tfID);
+               ctx.expectError                                 (GL_NO_ERROR);
+               ctx.endSection                                  ();
+       }
 
        ctx.glUseProgram(0);
 }
@@ -651,34 +658,37 @@ void draw_elements_instanced (NegativeTestContext& ctx)
        ctx.glDeleteFramebuffers(1, &fbo);
        ctx.endSection();
 
-       ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-       const char* tfVarying           = "gl_Position";
-
-       ctx.glGenBuffers                                (1, &buf);
-       ctx.glGenTransformFeedbacks             (1, &tfID);
-
-       ctx.glUseProgram                                (program.getProgram());
-       ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-       ctx.glLinkProgram                               (program.getProgram());
-       ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
-       ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-       ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-       ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-       ctx.glBeginTransformFeedback    (GL_POINTS);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glDrawElementsInstanced             (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
-       ctx.expectError                         (GL_INVALID_OPERATION);
-
-       ctx.glPauseTransformFeedback();
-       ctx.glDrawElementsInstanced             (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glEndTransformFeedback              ();
-       ctx.glDeleteBuffers                             (1, &buf);
-       ctx.glDeleteTransformFeedbacks  (1, &tfID);
-       ctx.expectError                         (GL_NO_ERROR);
-       ctx.endSection();
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+       {
+               ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+               const char* tfVarying           = "gl_Position";
+
+               ctx.glGenBuffers                                (1, &buf);
+               ctx.glGenTransformFeedbacks             (1, &tfID);
+
+               ctx.glUseProgram                                (program.getProgram());
+               ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+               ctx.glLinkProgram                               (program.getProgram());
+               ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
+               ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+               ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+               ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+               ctx.glBeginTransformFeedback    (GL_POINTS);
+               ctx.expectError                         (GL_NO_ERROR);
+
+               ctx.glDrawElementsInstanced             (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
+               ctx.expectError                         (GL_INVALID_OPERATION);
+
+               ctx.glPauseTransformFeedback();
+               ctx.glDrawElementsInstanced             (GL_POINTS, 1, GL_UNSIGNED_BYTE, vertices, 1);
+               ctx.expectError                         (GL_NO_ERROR);
+
+               ctx.glEndTransformFeedback              ();
+               ctx.glDeleteBuffers                             (1, &buf);
+               ctx.glDeleteTransformFeedbacks  (1, &tfID);
+               ctx.expectError                         (GL_NO_ERROR);
+               ctx.endSection();
+       }
 
        ctx.glUseProgram(0);
 }
@@ -761,34 +771,37 @@ void draw_elements_instanced_incomplete_primitive (NegativeTestContext& ctx)
        ctx.glDeleteFramebuffers(1, &fbo);
        ctx.endSection();
 
-       ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-       const char* tfVarying           = "gl_Position";
-
-       ctx.glGenBuffers                                (1, &buf);
-       ctx.glGenTransformFeedbacks             (1, &tfID);
-
-       ctx.glUseProgram                                (program.getProgram());
-       ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-       ctx.glLinkProgram                               (program.getProgram());
-       ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
-       ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-       ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-       ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-       ctx.glBeginTransformFeedback    (GL_TRIANGLES);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glDrawElementsInstanced             (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
-       ctx.expectError                         (GL_INVALID_OPERATION);
-
-       ctx.glPauseTransformFeedback();
-       ctx.glDrawElementsInstanced             (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glEndTransformFeedback              ();
-       ctx.glDeleteBuffers                             (1, &buf);
-       ctx.glDeleteTransformFeedbacks  (1, &tfID);
-       ctx.expectError                         (GL_NO_ERROR);
-       ctx.endSection();
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+       {
+               ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+               const char* tfVarying           = "gl_Position";
+
+               ctx.glGenBuffers                                (1, &buf);
+               ctx.glGenTransformFeedbacks             (1, &tfID);
+
+               ctx.glUseProgram                                (program.getProgram());
+               ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+               ctx.glLinkProgram                               (program.getProgram());
+               ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
+               ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+               ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+               ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+               ctx.glBeginTransformFeedback    (GL_TRIANGLES);
+               ctx.expectError                                 (GL_NO_ERROR);
+
+               ctx.glDrawElementsInstanced             (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
+               ctx.expectError                                 (GL_INVALID_OPERATION);
+
+               ctx.glPauseTransformFeedback();
+               ctx.glDrawElementsInstanced             (GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, vertices, 1);
+               ctx.expectError                                 (GL_NO_ERROR);
+
+               ctx.glEndTransformFeedback              ();
+               ctx.glDeleteBuffers                             (1, &buf);
+               ctx.glDeleteTransformFeedbacks  (1, &tfID);
+               ctx.expectError                                 (GL_NO_ERROR);
+               ctx.endSection();
+       }
 
        ctx.glUseProgram(0);
 }
@@ -834,34 +847,37 @@ void draw_range_elements (NegativeTestContext& ctx)
        ctx.glDeleteFramebuffers(1, &fbo);
        ctx.endSection();
 
-       ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-       const char* tfVarying           = "gl_Position";
-
-       ctx.glGenBuffers                                (1, &buf);
-       ctx.glGenTransformFeedbacks             (1, &tfID);
-
-       ctx.glUseProgram                                (program.getProgram());
-       ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-       ctx.glLinkProgram                               (program.getProgram());
-       ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
-       ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-       ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-       ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-       ctx.glBeginTransformFeedback    (GL_POINTS);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glDrawRangeElements                 (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_INVALID_OPERATION);
-
-       ctx.glPauseTransformFeedback();
-       ctx.glDrawRangeElements                 (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glEndTransformFeedback              ();
-       ctx.glDeleteBuffers                             (1, &buf);
-       ctx.glDeleteTransformFeedbacks  (1, &tfID);
-       ctx.expectError                         (GL_NO_ERROR);
-       ctx.endSection();
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+       {
+               ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+               const char* tfVarying           = "gl_Position";
+
+               ctx.glGenBuffers                                (1, &buf);
+               ctx.glGenTransformFeedbacks             (1, &tfID);
+
+               ctx.glUseProgram                                (program.getProgram());
+               ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+               ctx.glLinkProgram                               (program.getProgram());
+               ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
+               ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+               ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+               ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+               ctx.glBeginTransformFeedback    (GL_POINTS);
+               ctx.expectError                                 (GL_NO_ERROR);
+
+               ctx.glDrawRangeElements                 (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                                 (GL_INVALID_OPERATION);
+
+               ctx.glPauseTransformFeedback();
+               ctx.glDrawRangeElements                 (GL_POINTS, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                                 (GL_NO_ERROR);
+
+               ctx.glEndTransformFeedback              ();
+               ctx.glDeleteBuffers                             (1, &buf);
+               ctx.glDeleteTransformFeedbacks  (1, &tfID);
+               ctx.expectError                                 (GL_NO_ERROR);
+               ctx.endSection();
+       }
 
        ctx.glUseProgram(0);
 }
@@ -946,34 +962,37 @@ void draw_range_elements_incomplete_primitive (NegativeTestContext& ctx)
        ctx.glDeleteFramebuffers(1, &fbo);
        ctx.endSection();
 
-       ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
-       const char* tfVarying           = "gl_Position";
-
-       ctx.glGenBuffers                                (1, &buf);
-       ctx.glGenTransformFeedbacks             (1, &tfID);
-
-       ctx.glUseProgram                                (program.getProgram());
-       ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
-       ctx.glLinkProgram                               (program.getProgram());
-       ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
-       ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
-       ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
-       ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
-       ctx.glBeginTransformFeedback    (GL_TRIANGLES);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glDrawRangeElements                 (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_INVALID_OPERATION);
-
-       ctx.glPauseTransformFeedback();
-       ctx.glDrawRangeElements                 (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
-       ctx.expectError                         (GL_NO_ERROR);
-
-       ctx.glEndTransformFeedback              ();
-       ctx.glDeleteBuffers                             (1, &buf);
-       ctx.glDeleteTransformFeedbacks  (1, &tfID);
-       ctx.expectError                         (GL_NO_ERROR);
-       ctx.endSection();
+       if (!ctx.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader")) // GL_EXT_geometry_shader removes error
+       {
+               ctx.beginSection("GL_INVALID_OPERATION is generated if transform feedback is active and not paused.");
+               const char* tfVarying           = "gl_Position";
+
+               ctx.glGenBuffers                                (1, &buf);
+               ctx.glGenTransformFeedbacks             (1, &tfID);
+
+               ctx.glUseProgram                                (program.getProgram());
+               ctx.glTransformFeedbackVaryings (program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+               ctx.glLinkProgram                               (program.getProgram());
+               ctx.glBindTransformFeedback             (GL_TRANSFORM_FEEDBACK, tfID);
+               ctx.glBindBuffer                                (GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+               ctx.glBufferData                                (GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+               ctx.glBindBufferBase                    (GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+               ctx.glBeginTransformFeedback    (GL_TRIANGLES);
+               ctx.expectError                         (GL_NO_ERROR);
+
+               ctx.glDrawRangeElements                 (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                         (GL_INVALID_OPERATION);
+
+               ctx.glPauseTransformFeedback();
+               ctx.glDrawRangeElements                 (GL_TRIANGLES, 0, 1, 1, GL_UNSIGNED_BYTE, vertices);
+               ctx.expectError                         (GL_NO_ERROR);
+
+               ctx.glEndTransformFeedback              ();
+               ctx.glDeleteBuffers                             (1, &buf);
+               ctx.glDeleteTransformFeedbacks  (1, &tfID);
+               ctx.expectError                         (GL_NO_ERROR);
+               ctx.endSection();
+       }
 
        ctx.glUseProgram(0);
 }