[Piglit] [PATCH] gl-1.0/beginend-coverage: New test.
Eric Anholt
eric at anholt.net
Fri Jan 18 12:35:24 PST 2013
As I was rewriting a bunch of the begin/end error handling in Mesa, I
discovered that neither piglit nor oglconform had any decent testing
of it. After a fix, Mesa passes all but
DrawArrays/DrawElements/EndList (so those probably deserve extra
review to see if what those subtests are expecting match our
understanding of the GL spec).
---
tests/all.tests | 1 +
tests/spec/gl-1.0/CMakeLists.gl.txt | 1 +
tests/spec/gl-1.0/beginend-coverage.c | 932 +++++++++++++++++++++++++++++++++
3 files changed, 934 insertions(+)
create mode 100644 tests/spec/gl-1.0/beginend-coverage.c
diff --git a/tests/all.tests b/tests/all.tests
index 88f009e..fe95dc9 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -548,6 +548,7 @@ add_concurrent_test(gl11, 'getteximage-targets 2D')
gl10 = Group()
spec['!OpenGL 1.0'] = gl10
+add_concurrent_test(gl10, 'gl-1.0-beginend-coverage')
add_concurrent_test(gl10, 'gl-1.0-edgeflag')
add_concurrent_test(gl10, 'gl-1.0-edgeflag-quads')
diff --git a/tests/spec/gl-1.0/CMakeLists.gl.txt b/tests/spec/gl-1.0/CMakeLists.gl.txt
index db7fe01..2f819fa 100644
--- a/tests/spec/gl-1.0/CMakeLists.gl.txt
+++ b/tests/spec/gl-1.0/CMakeLists.gl.txt
@@ -9,6 +9,7 @@ link_libraries (
${OPENGL_glu_LIBRARY}
)
+piglit_add_executable (gl-1.0-beginend-coverage beginend-coverage.c)
piglit_add_executable (gl-1.0-edgeflag edgeflag.c)
piglit_add_executable (gl-1.0-edgeflag-quads edgeflag-quads.c)
diff --git a/tests/spec/gl-1.0/beginend-coverage.c b/tests/spec/gl-1.0/beginend-coverage.c
new file mode 100644
index 0000000..64d603c
--- /dev/null
+++ b/tests/spec/gl-1.0/beginend-coverage.c
@@ -0,0 +1,932 @@
+/* Copyright © 2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/** @file beginend-coverage.c
+ *
+ * Test that various functions correctly throw errors or not while
+ * inside a glBegin()/glEnd() block, whether inside or outside a
+ * display list.
+ *
+ * From the GL 1.0 specification section 2.6.3, "GL Commands within
+ * Begin/End"
+ *
+ * "The only GL commands that are allowed within any Begin/End
+ * pairs are the commands for specifying vertex coordinates,
+ * vertex color, normal coordinates, and texture coordinates
+ * (Vertex, Color, Index, Normal, TexCoord), EvalCoord and
+ * EvalPoint commands (see section 5.1), commands for specifying
+ * lighting material parameters (Material commands see section
+ * 2.12.2), display list invocation commands (CallList and
+ * CallLists see section 5.4), and the EdgeFlag
+ * command. Executing Begin after Begin has already been executed
+ * but before an End is issued generates the INVALID OPERATION
+ * error, as does executing End without a previous corresponding
+ * Begin. Executing any other GL command within Begin/End results
+ * in the error INVALID OPERATION."
+ */
+
+#include "piglit-util-gl-common.h"
+#include "minmax-test.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+
+ config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_ALPHA;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+struct test {
+ const char *name;
+ void (*func)(void);
+};
+
+extern bool piglit_use_fbo;
+static uint32_t junk_storage[1024];
+static void *junk = junk_storage;
+static const int onei = 1;
+static const float onef = 1.0;
+static GLuint some_dlist;
+static GLuint newlist_dlist;
+static GLuint deletelists_dlist;
+static GLuint fbo_attachment;
+
+#define TEST_FUNC(name, args) \
+ static void test_##name(void) \
+ { \
+ name args; \
+ }
+;
+TEST_FUNC(glAccum, (GL_ADD, 1.0))
+TEST_FUNC(glAlphaFunc, (GL_GREATER, 0.0))
+TEST_FUNC(glArrayElement, (0))
+TEST_FUNC(glBegin, (GL_POINTS))
+TEST_FUNC(glBitmap, (1, 1, 0, 0, 0, 0, (const GLubyte *)junk))
+TEST_FUNC(glBlendFunc, (GL_ZERO, GL_ZERO))
+TEST_FUNC(glCallList, (some_dlist))
+/* relies on ListBase == 0 */
+TEST_FUNC(glCallLists, (1, GL_UNSIGNED_INT, &some_dlist))
+TEST_FUNC(glClear, (GL_COLOR_BUFFER_BIT))
+TEST_FUNC(glClearAccum, (0, 0, 0, 0))
+TEST_FUNC(glClearColor, (0, 0, 0 ,0))
+TEST_FUNC(glClearDepth, (0))
+TEST_FUNC(glClearIndex, (0))
+TEST_FUNC(glClearStencil, (0))
+TEST_FUNC(glClipPlane, (GL_CLIP_PLANE0, junk))
+TEST_FUNC(glColor3b, (0, 0, 0))
+TEST_FUNC(glColor3bv, (junk))
+TEST_FUNC(glColor3d, (0, 0, 0))
+TEST_FUNC(glColor3dv, (junk))
+TEST_FUNC(glColor3f, (0, 0, 0))
+TEST_FUNC(glColor3fv, (junk))
+TEST_FUNC(glColor3i, (0, 0, 0))
+TEST_FUNC(glColor3iv, (junk))
+TEST_FUNC(glColor3s, (0, 0, 0))
+TEST_FUNC(glColor3sv, (junk))
+TEST_FUNC(glColor3ub, (0, 0, 0))
+TEST_FUNC(glColor3ubv, (junk))
+TEST_FUNC(glColor3ui, (0, 0, 0))
+TEST_FUNC(glColor3uiv, (junk))
+TEST_FUNC(glColor3us, (0, 0, 0))
+TEST_FUNC(glColor3usv, (junk))
+TEST_FUNC(glColor4b, (0, 0, 0, 0))
+TEST_FUNC(glColor4bv, (junk))
+TEST_FUNC(glColor4d, (0, 0, 0, 0))
+TEST_FUNC(glColor4dv, (junk))
+TEST_FUNC(glColor4f, (0, 0, 0, 0))
+TEST_FUNC(glColor4fv, (junk))
+TEST_FUNC(glColor4i, (0, 0, 0, 0))
+TEST_FUNC(glColor4iv, (junk))
+TEST_FUNC(glColor4s, (0, 0, 0, 0))
+TEST_FUNC(glColor4sv, (junk))
+TEST_FUNC(glColor4ub, (0, 0, 0, 0))
+TEST_FUNC(glColor4ubv, (junk))
+TEST_FUNC(glColor4ui, (0, 0, 0, 0))
+TEST_FUNC(glColor4uiv, (junk))
+TEST_FUNC(glColor4us, (0, 0, 0, 0))
+TEST_FUNC(glColor4usv, (junk))
+TEST_FUNC(glColorMask, (0, 0, 0, 0))
+TEST_FUNC(glColorMaterial, (GL_FRONT, GL_AMBIENT))
+TEST_FUNC(glColorPointer, (4, GL_FLOAT, 0, junk))
+TEST_FUNC(glCopyPixels, (0, 0, 1, 1, GL_COLOR))
+TEST_FUNC(glCullFace, (GL_FRONT))
+TEST_FUNC(glDepthFunc, (GL_GREATER))
+TEST_FUNC(glDepthMask, (0))
+TEST_FUNC(glDepthRange, (0, 1))
+TEST_FUNC(glDeleteLists, (deletelists_dlist, 1))
+TEST_FUNC(glDisable, (GL_DEPTH_TEST))
+TEST_FUNC(glDisableClientState, (GL_VERTEX_ARRAY))
+TEST_FUNC(glDrawArrays, (GL_POINTS, 0, 1))
+TEST_FUNC(glDrawBuffer, (fbo_attachment))
+TEST_FUNC(glDrawElements, (GL_POINTS, 1, GL_UNSIGNED_INT, junk))
+TEST_FUNC(glDrawPixels, (1, 1, GL_RGBA, GL_FLOAT, junk))
+TEST_FUNC(glEdgeFlag, (0))
+TEST_FUNC(glEdgeFlagPointer, (0, junk))
+TEST_FUNC(glEdgeFlagv, (junk))
+TEST_FUNC(glEnable, (GL_DEPTH_TEST))
+TEST_FUNC(glEnableClientState, (GL_VERTEX_ARRAY))
+/* No particular test for End inside of a begin/end block, obviously. */
+TEST_FUNC(glEndList, ())
+TEST_FUNC(glFrontFace, (GL_CW))
+TEST_FUNC(glGenLists, (1))
+TEST_FUNC(glGetBooleanv, (GL_DEPTH_TEST, junk))
+TEST_FUNC(glGetClipPlane, (0, junk))
+TEST_FUNC(glGetDoublev, (GL_DEPTH_TEST, junk))
+TEST_FUNC(glGetError, ())
+TEST_FUNC(glGetFloatv, (GL_DEPTH_TEST, junk))
+TEST_FUNC(glGetIntegerv, (GL_DEPTH_TEST, junk))
+TEST_FUNC(glGetLightfv, (GL_LIGHT0, GL_SPOT_CUTOFF, junk))
+TEST_FUNC(glGetLightiv, (GL_LIGHT0, GL_SPOT_CUTOFF, junk))
+TEST_FUNC(glGetMaterialfv, (GL_FRONT, GL_AMBIENT, junk))
+TEST_FUNC(glGetMaterialiv, (GL_FRONT, GL_AMBIENT, junk))
+TEST_FUNC(glGetPolygonStipple, (junk))
+TEST_FUNC(glGetString, (GL_EXTENSIONS))
+TEST_FUNC(glGetPixelMapfv, (GL_PIXEL_MAP_S_TO_S, junk))
+TEST_FUNC(glGetPixelMapuiv, (GL_PIXEL_MAP_S_TO_S, junk))
+TEST_FUNC(glGetPixelMapusv, (GL_PIXEL_MAP_S_TO_S, junk))
+TEST_FUNC(glGetPointerv, (GL_VERTEX_ARRAY_POINTER, junk))
+TEST_FUNC(glGetTexEnvfv, (GL_TEXTURE_2D, GL_ALPHA_SCALE, junk))
+TEST_FUNC(glGetTexEnviv, (GL_TEXTURE_2D, GL_ALPHA_SCALE, junk))
+TEST_FUNC(glGetTexGendv, (GL_S, GL_OBJECT_PLANE, junk))
+TEST_FUNC(glGetTexGenfv, (GL_S, GL_OBJECT_PLANE, junk))
+TEST_FUNC(glGetTexGeniv, (GL_S, GL_OBJECT_PLANE, junk))
+TEST_FUNC(glGetTexImage, (GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, junk))
+TEST_FUNC(glGetTexLevelParameterfv, (GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, junk))
+TEST_FUNC(glGetTexLevelParameteriv, (GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, junk))
+TEST_FUNC(glGetTexParameterfv, (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, junk))
+TEST_FUNC(glGetTexParameteriv, (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, junk))
+TEST_FUNC(glFinish, ())
+TEST_FUNC(glFlush, ())
+TEST_FUNC(glFrustum, (0, 1, 0, 1, 0.1, 1))
+TEST_FUNC(glHint, (GL_FOG_HINT, GL_NICEST))
+TEST_FUNC(glIndexMask, (0))
+TEST_FUNC(glIsEnabled, (GL_DEPTH_TEST))
+TEST_FUNC(glIsList, (0))
+TEST_FUNC(glIndexd, (0))
+TEST_FUNC(glIndexdv, (junk))
+TEST_FUNC(glIndexf, (0))
+TEST_FUNC(glIndexfv, (junk))
+TEST_FUNC(glIndexi, (0))
+TEST_FUNC(glIndexiv, (junk))
+TEST_FUNC(glIndexPointer, (GL_BYTE, 0, junk))
+TEST_FUNC(glIndexs, (0))
+TEST_FUNC(glIndexsv, (junk))
+TEST_FUNC(glIndexub, (0))
+TEST_FUNC(glIndexubv, (junk))
+TEST_FUNC(glInterleavedArrays, (GL_V2F, 0, junk))
+TEST_FUNC(glLightf, (GL_LIGHT0, GL_SPOT_CUTOFF, 0))
+TEST_FUNC(glLightfv, (GL_LIGHT0, GL_SPOT_CUTOFF, junk))
+TEST_FUNC(glLighti, (GL_LIGHT0, GL_SPOT_CUTOFF, 0))
+TEST_FUNC(glLightiv, (GL_LIGHT0, GL_SPOT_CUTOFF, junk))
+TEST_FUNC(glLightModelf, (GL_LIGHT_MODEL_AMBIENT, 0))
+TEST_FUNC(glLightModelfv, (GL_LIGHT_MODEL_AMBIENT, junk))
+TEST_FUNC(glLightModeli, (GL_LIGHT_MODEL_AMBIENT, 0))
+TEST_FUNC(glLightModeliv, (GL_LIGHT_MODEL_AMBIENT, junk))
+TEST_FUNC(glLineStipple, (0, 0))
+TEST_FUNC(glLineWidth, (1))
+TEST_FUNC(glListBase, (0))
+TEST_FUNC(glLoadIdentity, ())
+TEST_FUNC(glLoadMatrixd, (junk))
+TEST_FUNC(glLoadMatrixf, (junk))
+TEST_FUNC(glLogicOp, (GL_COPY))
+TEST_FUNC(glMaterialf, (GL_FRONT, GL_AMBIENT, 0))
+TEST_FUNC(glMaterialfv, (GL_FRONT, GL_AMBIENT, junk))
+TEST_FUNC(glMateriali, (GL_FRONT, GL_AMBIENT, 0))
+TEST_FUNC(glMaterialiv, (GL_FRONT, GL_AMBIENT, junk))
+TEST_FUNC(glMatrixMode, (GL_MODELVIEW))
+TEST_FUNC(glMultMatrixd, (junk))
+TEST_FUNC(glMultMatrixf, (junk))
+TEST_FUNC(glNewList, (newlist_dlist, GL_COMPILE))
+TEST_FUNC(glNormal3d, (0, 0, 0))
+TEST_FUNC(glNormal3f, (0, 0, 0))
+TEST_FUNC(glNormal3i, (0, 0, 0))
+TEST_FUNC(glNormal3s, (0, 0, 0))
+TEST_FUNC(glNormal3dv, (junk))
+TEST_FUNC(glNormal3fv, (junk))
+TEST_FUNC(glNormal3iv, (junk))
+TEST_FUNC(glNormal3sv, (junk))
+TEST_FUNC(glNormalPointer, (GL_FLOAT, 0, junk))
+TEST_FUNC(glOrtho, (0, 1, 0, 1, 0, 1))
+TEST_FUNC(glReadPixels, (0, 0, 1, 1, GL_RGBA, GL_FLOAT, junk))
+TEST_FUNC(glRotated, (0, 0, 0, 1))
+TEST_FUNC(glRotatef, (0, 0, 0, 1))
+TEST_FUNC(glScaled, (0, 0, 0))
+TEST_FUNC(glScalef, (0, 0, 0))
+TEST_FUNC(glShadeModel, (GL_SMOOTH))
+TEST_FUNC(glTranslated, (0, 0, 0))
+TEST_FUNC(glTranslatef, (0, 0, 0))
+TEST_FUNC(glPixelMapfv, (GL_PIXEL_MAP_S_TO_S, 1, junk))
+TEST_FUNC(glPixelMapuiv, (GL_PIXEL_MAP_S_TO_S, 1, junk))
+TEST_FUNC(glPixelMapusv, (GL_PIXEL_MAP_S_TO_S, 1, junk))
+TEST_FUNC(glPixelStoref, (GL_UNPACK_ROW_LENGTH, 0))
+TEST_FUNC(glPixelStorei, (GL_UNPACK_ROW_LENGTH, 0))
+TEST_FUNC(glPixelTransferf, (GL_MAP_COLOR, 0))
+TEST_FUNC(glPixelTransferi, (GL_MAP_COLOR, 0))
+TEST_FUNC(glPixelZoom, (0, 0))
+TEST_FUNC(glPointSize, (1))
+static void test_glPushAttrib() {
+ glPushAttrib(GL_COLOR_BUFFER_BIT);
+ glPopAttrib();
+}
+static void test_glPushClientAttrib() {
+ glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
+ glPopClientAttrib();
+}
+static void test_glPushMatrix() {
+ glPushMatrix();
+ glPopMatrix();
+}
+TEST_FUNC(glPolygonStipple, (junk))
+TEST_FUNC(glRasterPos2d, (0, 0))
+TEST_FUNC(glRasterPos2dv, (junk))
+TEST_FUNC(glRasterPos2f, (0, 0))
+TEST_FUNC(glRasterPos2fv, (junk))
+TEST_FUNC(glRasterPos2i, (0, 0))
+TEST_FUNC(glRasterPos2iv, (junk))
+TEST_FUNC(glRasterPos2s, (0, 0))
+TEST_FUNC(glRasterPos2sv, (junk))
+TEST_FUNC(glRasterPos3d, (0, 0, 0))
+TEST_FUNC(glRasterPos3dv, (junk))
+TEST_FUNC(glRasterPos3f, (0, 0, 0))
+TEST_FUNC(glRasterPos3fv, (junk))
+TEST_FUNC(glRasterPos3i, (0, 0, 0))
+TEST_FUNC(glRasterPos3iv, (junk))
+TEST_FUNC(glRasterPos3s, (0, 0, 0))
+TEST_FUNC(glRasterPos3sv, (junk))
+TEST_FUNC(glReadBuffer, (fbo_attachment))
+TEST_FUNC(glRectd, (0, 0, 0, 0))
+TEST_FUNC(glRectdv, (junk, junk))
+TEST_FUNC(glRectf, (0, 0, 0, 0))
+TEST_FUNC(glRectfv, (junk, junk))
+TEST_FUNC(glRecti, (0, 0, 0, 0))
+TEST_FUNC(glRectiv, (junk, junk))
+TEST_FUNC(glRects, (0, 0, 0, 0))
+TEST_FUNC(glRectsv, (junk, junk))
+TEST_FUNC(glRenderMode, (GL_RENDER))
+TEST_FUNC(glScissor, (0, 0, 1, 1))
+TEST_FUNC(glStencilFunc, (GL_ALWAYS, 0, 0))
+TEST_FUNC(glStencilMask, (0))
+TEST_FUNC(glStencilOp, (GL_REPLACE, GL_REPLACE, GL_REPLACE))
+TEST_FUNC(glTexCoord1d, (0))
+TEST_FUNC(glTexCoord1dv, (junk))
+TEST_FUNC(glTexCoord1f, (0))
+TEST_FUNC(glTexCoord1fv, (junk))
+TEST_FUNC(glTexCoord1i, (0))
+TEST_FUNC(glTexCoord1iv, (junk))
+TEST_FUNC(glTexCoord1s, (0))
+TEST_FUNC(glTexCoord1sv, (junk))
+TEST_FUNC(glTexCoord2d, (0, 0))
+TEST_FUNC(glTexCoord2dv, (junk))
+TEST_FUNC(glTexCoord2f, (0, 0))
+TEST_FUNC(glTexCoord2fv, (junk))
+TEST_FUNC(glTexCoord2i, (0, 0))
+TEST_FUNC(glTexCoord2iv, (junk))
+TEST_FUNC(glTexCoord2s, (0, 0))
+TEST_FUNC(glTexCoord2sv, (junk))
+TEST_FUNC(glTexCoord3d, (0, 0, 0))
+TEST_FUNC(glTexCoord3dv, (junk))
+TEST_FUNC(glTexCoord3f, (0, 0, 0))
+TEST_FUNC(glTexCoord3fv, (junk))
+TEST_FUNC(glTexCoord3i, (0, 0, 0))
+TEST_FUNC(glTexCoord3iv, (junk))
+TEST_FUNC(glTexCoord3s, (0, 0, 0))
+TEST_FUNC(glTexCoord3sv, (junk))
+TEST_FUNC(glTexCoord4d, (0, 0, 0, 0))
+TEST_FUNC(glTexCoord4dv, (junk))
+TEST_FUNC(glTexCoord4f, (0, 0, 0, 0))
+TEST_FUNC(glTexCoord4fv, (junk))
+TEST_FUNC(glTexCoord4i, (0, 0, 0, 0))
+TEST_FUNC(glTexCoord4iv, (junk))
+TEST_FUNC(glTexCoord4s, (0, 0, 0, 0))
+TEST_FUNC(glTexCoord4sv, (junk))
+TEST_FUNC(glTexCoordPointer, (4, GL_FLOAT, 0, junk))
+TEST_FUNC(glTexEnvf, (GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1))
+TEST_FUNC(glTexEnvfv, (GL_TEXTURE_ENV, GL_ALPHA_SCALE, &onef))
+TEST_FUNC(glTexEnvi, (GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1))
+TEST_FUNC(glTexEnviv, (GL_TEXTURE_ENV, GL_ALPHA_SCALE, &onei))
+TEST_FUNC(glTexGend, (GL_S, GL_OBJECT_PLANE, 0))
+TEST_FUNC(glTexGendv, (GL_S, GL_OBJECT_PLANE, junk))
+TEST_FUNC(glTexGenf, (GL_S, GL_OBJECT_PLANE, 0))
+TEST_FUNC(glTexGenfv, (GL_S, GL_OBJECT_PLANE, junk))
+TEST_FUNC(glTexGeni, (GL_S, GL_OBJECT_PLANE, 0))
+TEST_FUNC(glTexGeniv, (GL_S, GL_OBJECT_PLANE, junk))
+TEST_FUNC(glTexImage1D, (GL_TEXTURE_1D, 0, GL_RGBA, 1, 0, GL_RGBA, GL_FLOAT, NULL))
+TEST_FUNC(glTexImage2D, (GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_FLOAT, NULL))
+TEST_FUNC(glTexParameterf, (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, 0))
+TEST_FUNC(glTexParameterfv, (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, junk))
+TEST_FUNC(glTexParameteri, (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, 0))
+TEST_FUNC(glTexParameteriv, (GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, junk))
+TEST_FUNC(glVertex2d, (0, 0))
+TEST_FUNC(glVertex2dv, (junk))
+TEST_FUNC(glVertex2f, (0, 0))
+TEST_FUNC(glVertex2fv, (junk))
+TEST_FUNC(glVertex2i, (0, 0))
+TEST_FUNC(glVertex2iv, (junk))
+TEST_FUNC(glVertex2s, (0, 0))
+TEST_FUNC(glVertex2sv, (junk))
+TEST_FUNC(glVertex3d, (0, 0, 0))
+TEST_FUNC(glVertex3dv, (junk))
+TEST_FUNC(glVertex3f, (0, 0, 0))
+TEST_FUNC(glVertex3fv, (junk))
+TEST_FUNC(glVertex3i, (0, 0, 0))
+TEST_FUNC(glVertex3iv, (junk))
+TEST_FUNC(glVertex3s, (0, 0, 0))
+TEST_FUNC(glVertex3sv, (junk))
+TEST_FUNC(glVertex4d, (0, 0, 0, 0))
+TEST_FUNC(glVertex4dv, (junk))
+TEST_FUNC(glVertex4f, (0, 0, 0, 0))
+TEST_FUNC(glVertex4fv, (junk))
+TEST_FUNC(glVertex4i, (0, 0, 0, 0))
+TEST_FUNC(glVertex4iv, (junk))
+TEST_FUNC(glVertex4s, (0, 0, 0, 0))
+TEST_FUNC(glVertex4sv, (junk))
+TEST_FUNC(glVertexPointer, (4, GL_FLOAT, 0, junk))
+TEST_FUNC(glViewport, (0, 0, 1, 1))
+
+#define TEST(a) { #a, test_##a }
+
+static struct test ok_tests[] = {
+ TEST(glArrayElement),
+ TEST(glCallList),
+ TEST(glCallLists),
+ TEST(glColor3b),
+ TEST(glColor3bv),
+ TEST(glColor3d),
+ TEST(glColor3dv),
+ TEST(glColor3f),
+ TEST(glColor3fv),
+ TEST(glColor3i),
+ TEST(glColor3iv),
+ TEST(glColor3s),
+ TEST(glColor3sv),
+ TEST(glColor3ub),
+ TEST(glColor3ubv),
+ TEST(glColor3ui),
+ TEST(glColor3uiv),
+ TEST(glColor3us),
+ TEST(glColor3usv),
+ TEST(glColor4b),
+ TEST(glColor4bv),
+ TEST(glColor4d),
+ TEST(glColor4dv),
+ TEST(glColor4f),
+ TEST(glColor4fv),
+ TEST(glColor4i),
+ TEST(glColor4iv),
+ TEST(glColor4s),
+ TEST(glColor4sv),
+ TEST(glColor4ub),
+ TEST(glColor4ubv),
+ TEST(glColor4ui),
+ TEST(glColor4uiv),
+ TEST(glColor4us),
+ TEST(glColor4usv),
+ TEST(glEdgeFlag),
+ TEST(glEdgeFlagv),
+ TEST(glIndexd),
+ TEST(glIndexdv),
+ TEST(glIndexf),
+ TEST(glIndexfv),
+ TEST(glIndexi),
+ TEST(glIndexiv),
+ TEST(glIndexs),
+ TEST(glIndexsv),
+ TEST(glIndexub),
+ TEST(glIndexubv),
+ TEST(glMaterialf),
+ TEST(glMaterialfv),
+ TEST(glMateriali),
+ TEST(glMaterialiv),
+ TEST(glNormal3d),
+ TEST(glNormal3dv),
+ TEST(glNormal3f),
+ TEST(glNormal3fv),
+ TEST(glNormal3i),
+ TEST(glNormal3iv),
+ TEST(glNormal3s),
+ TEST(glNormal3sv),
+ TEST(glTexCoord1d),
+ TEST(glTexCoord1dv),
+ TEST(glTexCoord1f),
+ TEST(glTexCoord1fv),
+ TEST(glTexCoord1i),
+ TEST(glTexCoord1iv),
+ TEST(glTexCoord1s),
+ TEST(glTexCoord1sv),
+ TEST(glTexCoord2d),
+ TEST(glTexCoord2dv),
+ TEST(glTexCoord2f),
+ TEST(glTexCoord2fv),
+ TEST(glTexCoord2i),
+ TEST(glTexCoord2iv),
+ TEST(glTexCoord2s),
+ TEST(glTexCoord2sv),
+ TEST(glTexCoord3d),
+ TEST(glTexCoord3dv),
+ TEST(glTexCoord3f),
+ TEST(glTexCoord3fv),
+ TEST(glTexCoord3i),
+ TEST(glTexCoord3iv),
+ TEST(glTexCoord3s),
+ TEST(glTexCoord3sv),
+ TEST(glTexCoord4d),
+ TEST(glTexCoord4dv),
+ TEST(glTexCoord4f),
+ TEST(glTexCoord4fv),
+ TEST(glTexCoord4i),
+ TEST(glTexCoord4iv),
+ TEST(glTexCoord4s),
+ TEST(glTexCoord4sv),
+ TEST(glVertex2d),
+ TEST(glVertex2dv),
+ TEST(glVertex2f),
+ TEST(glVertex2fv),
+ TEST(glVertex2i),
+ TEST(glVertex2iv),
+ TEST(glVertex2s),
+ TEST(glVertex2sv),
+ TEST(glVertex3d),
+ TEST(glVertex3dv),
+ TEST(glVertex3f),
+ TEST(glVertex3fv),
+ TEST(glVertex3i),
+ TEST(glVertex3iv),
+ TEST(glVertex3s),
+ TEST(glVertex3sv),
+ TEST(glVertex4d),
+ TEST(glVertex4dv),
+ TEST(glVertex4f),
+ TEST(glVertex4fv),
+ TEST(glVertex4i),
+ TEST(glVertex4iv),
+ TEST(glVertex4s),
+ TEST(glVertex4sv),
+};
+
+static struct test error_tests[] = {
+ TEST(glAlphaFunc),
+ TEST(glBlendFunc),
+ TEST(glBitmap),
+ TEST(glClear),
+ TEST(glClearAccum),
+ TEST(glClearColor),
+ TEST(glClearDepth),
+ TEST(glClearIndex),
+ TEST(glClearStencil),
+ TEST(glClipPlane),
+ TEST(glColorMask),
+ TEST(glColorMaterial),
+ TEST(glCopyPixels),
+ TEST(glCullFace),
+ TEST(glDepthFunc),
+ TEST(glDepthMask),
+ TEST(glDepthRange),
+ TEST(glDisable),
+ TEST(glDrawArrays),
+ TEST(glDrawBuffer),
+ TEST(glDrawElements),
+ TEST(glDrawPixels),
+ TEST(glEnable),
+ TEST(glFrontFace),
+ TEST(glFrustum),
+ TEST(glHint),
+ TEST(glIndexMask),
+ TEST(glLightf),
+ TEST(glLightfv),
+ TEST(glLighti),
+ TEST(glLightiv),
+ TEST(glLightModelf),
+ TEST(glLightModelfv),
+ TEST(glLightModeli),
+ TEST(glLightModeliv),
+ TEST(glLineStipple),
+ TEST(glLineWidth),
+ TEST(glListBase),
+ TEST(glLoadIdentity),
+ TEST(glLoadMatrixd),
+ TEST(glLoadMatrixf),
+ TEST(glLogicOp),
+ TEST(glMatrixMode),
+ TEST(glMultMatrixd),
+ TEST(glMultMatrixf),
+ TEST(glOrtho),
+ TEST(glRotated),
+ TEST(glRotatef),
+ TEST(glScaled),
+ TEST(glScalef),
+ TEST(glShadeModel),
+ TEST(glTranslated),
+ TEST(glTranslatef),
+ TEST(glPixelMapfv),
+ TEST(glPixelMapuiv),
+ TEST(glPixelMapusv),
+ TEST(glPixelTransferf),
+ TEST(glPixelTransferi),
+ TEST(glPixelZoom),
+ TEST(glPointSize),
+ TEST(glPushAttrib),
+ TEST(glPushMatrix),
+ TEST(glPolygonStipple),
+ TEST(glRasterPos2d),
+ TEST(glRasterPos2dv),
+ TEST(glRasterPos2f),
+ TEST(glRasterPos2fv),
+ TEST(glRasterPos2i),
+ TEST(glRasterPos2iv),
+ TEST(glRasterPos2s),
+ TEST(glRasterPos2sv),
+ TEST(glRasterPos3d),
+ TEST(glRasterPos3dv),
+ TEST(glRasterPos3f),
+ TEST(glRasterPos3fv),
+ TEST(glRasterPos3i),
+ TEST(glRasterPos3iv),
+ TEST(glRasterPos3s),
+ TEST(glRasterPos3sv),
+ TEST(glReadBuffer),
+ TEST(glRectd),
+ TEST(glRectdv),
+ TEST(glRectf),
+ TEST(glRectfv),
+ TEST(glRecti),
+ TEST(glRectiv),
+ TEST(glRects),
+ TEST(glRectsv),
+ TEST(glScissor),
+ TEST(glStencilFunc),
+ TEST(glStencilMask),
+ TEST(glStencilOp),
+ TEST(glTexEnvf),
+ TEST(glTexEnvfv),
+ TEST(glTexEnvi),
+ TEST(glTexEnviv),
+ TEST(glTexGend),
+ TEST(glTexGendv),
+ TEST(glTexGenf),
+ TEST(glTexGenfv),
+ TEST(glTexGeni),
+ TEST(glTexGeniv),
+ TEST(glTexImage1D),
+ TEST(glTexImage2D),
+ TEST(glTexParameterf),
+ TEST(glTexParameterfv),
+ TEST(glTexParameteri),
+ TEST(glTexParameteriv),
+ TEST(glViewport),
+};
+
+/* From the GL 1.2.1 specification, section 5.4 ("Display Lists"):
+ *
+ * "Certain commands, when called while compiling a display list,
+ * are not compiled into the display list but are executed
+ * immediately. These are: IsList, GenLists, DeleteLists,
+ * FeedbackBuffer, SelectBuffer, RenderMode, VertexPointer,
+ * NormalPointer, ColorPointer, IndexPointer, TexCoordPointer,
+ * EdgeFlagPointer, InterleavedArrays, EnableClientState,
+ * DisableClientState, PushClientAttrib, PopClientAttrib,
+ * ReadPixels, PixelStore, GenTextures, DeleteTextures,
+ * AreTexturesResident, IsTexture, Flush, Finish, as well as
+ * IsEnabled and all of the Get commands (see Chapter 6)."
+ *
+ * The 1.0 spec didn't mention the Pointer or ClientAttrib functions,
+ * but this appears to be a correction.
+ */
+static struct test nondlist_error_tests[] = {
+ TEST(glColorPointer),
+ TEST(glDeleteLists),
+ TEST(glDisableClientState),
+ TEST(glEdgeFlagPointer),
+ TEST(glEnableClientState),
+ TEST(glIndexPointer),
+ TEST(glNewList),
+ TEST(glNormalPointer),
+ TEST(glGenLists),
+ TEST(glGetBooleanv),
+ TEST(glGetClipPlane),
+ TEST(glGetDoublev),
+ TEST(glGetError),
+ TEST(glGetFloatv),
+ TEST(glGetIntegerv),
+ TEST(glGetLightfv),
+ TEST(glGetLightiv),
+ TEST(glGetMaterialfv),
+ TEST(glGetMaterialiv),
+ TEST(glGetPolygonStipple),
+ TEST(glGetString),
+ TEST(glGetPixelMapfv),
+ TEST(glGetPixelMapuiv),
+ TEST(glGetPixelMapusv),
+ TEST(glGetPointerv),
+ TEST(glGetTexEnvfv),
+ TEST(glGetTexEnviv),
+ TEST(glGetTexGendv),
+ TEST(glGetTexGenfv),
+ TEST(glGetTexGeniv),
+ TEST(glGetTexImage),
+ TEST(glGetTexLevelParameterfv),
+ TEST(glGetTexLevelParameteriv),
+ TEST(glGetTexParameterfv),
+ TEST(glGetTexParameteriv),
+ TEST(glFinish),
+ TEST(glFlush),
+ TEST(glInterleavedArrays),
+ TEST(glIsEnabled),
+ TEST(glIsList),
+ TEST(glPixelStoref),
+ TEST(glPixelStorei),
+ TEST(glPushClientAttrib),
+ TEST(glReadPixels),
+ TEST(glRenderMode),
+ TEST(glTexCoordPointer),
+ TEST(glVertexPointer),
+};
+
+static struct test error_only_tests[] = {
+ /* No accum buffer is bound */
+ TEST(glAccum),
+ /* If it doesn't error out, it would need state cleanup. */
+ TEST(glBegin),
+};
+
+static struct test endlist_test = TEST(glEndList);
+
+enum piglit_result
+piglit_display()
+{
+ /* UNREACHED */
+ return PIGLIT_FAIL;
+}
+
+static bool
+test_beginend(struct test *test, GLenum expected_error)
+{
+ printf(" Testing within begin/end\n");
+
+ glBegin(GL_POINTS);
+ test->func();
+ glEnd();
+ if (!piglit_check_gl_error(expected_error)) {
+ fprintf(stderr, "after glEnd()\n");
+ return false;
+ }
+
+ return true;
+}
+
+static bool
+test_dlist_exec(struct test *test, GLenum expected_error)
+{
+ GLuint dlist;
+
+ printf(" Testing glCallList() inside begin/end\n");
+
+ dlist = glGenLists(1);
+ glNewList(dlist, GL_COMPILE);
+ test->func();
+ glEndList();
+ /* Nothing was executed yet, so no error should be present. */
+ if (!piglit_check_gl_error(GL_NO_ERROR)) {
+ fprintf(stderr, "after glEndList()\n");
+ return false;
+ }
+
+ glBegin(GL_POINTS);
+ glCallList(dlist);
+ glEnd();
+ if (!piglit_check_gl_error(expected_error)) {
+ fprintf(stderr, "after glCallList()\n");
+ return false;
+ }
+
+ glDeleteLists(dlist, 1);
+
+ return true;
+}
+
+static bool
+test_dlist_compile(struct test *test, GLenum expected_error)
+{
+ GLuint dlist;
+
+ printf(" Testing glNewList(GL_COMPILE) with begin/end inside\n");
+
+ dlist = glGenLists(1);
+ glNewList(dlist, GL_COMPILE);
+ glBegin(GL_POINTS);
+ test->func();
+ glEnd();
+ glEndList();
+ /* Nothing was executed yet, so no error should be present. */
+ if (!piglit_check_gl_error(GL_NO_ERROR)) {
+ fprintf(stderr, "after glEndList()\n");
+ return false;
+ }
+
+ glCallList(dlist);
+ if (!piglit_check_gl_error(expected_error)) {
+ fprintf(stderr, "after glCallList()\n");
+ return false;
+ }
+
+ glDeleteLists(dlist, 1);
+
+ return true;
+}
+
+static bool
+test_dlist_compile_exec(struct test *test, GLenum expected_error)
+{
+ GLuint dlist;
+
+ printf(" Testing glNewList(GL_COMPILE_AND_EXEC) with begin/end "
+ "inside\n");
+
+ dlist = glGenLists(1);
+ glNewList(dlist, GL_COMPILE_AND_EXECUTE);
+ glBegin(GL_POINTS);
+ test->func();
+ glEnd();
+ glEndList();
+ if (!piglit_check_gl_error(expected_error)) {
+ fprintf(stderr, "after glEndList()\n");
+ return false;
+ }
+
+ glCallList(dlist);
+ if (!piglit_check_gl_error(expected_error)) {
+ fprintf(stderr, "after glCallList()\n");
+ return false;
+ }
+
+ glDeleteLists(dlist, 1);
+
+ return true;
+}
+
+static bool
+test_dlist_compile_exec_after(struct test *test)
+{
+ GLuint dlist;
+
+ printf(" Testing glNewList(GL_COMPILE_AND_EXEC) with Begin/End "
+ "inside and the command after End\n");
+
+ dlist = glGenLists(1);
+ glNewList(dlist, GL_COMPILE_AND_EXECUTE);
+ glBegin(GL_POINTS);
+ glEnd();
+ test->func();
+ glEndList();
+ if (!piglit_check_gl_error(GL_NO_ERROR)) {
+ fprintf(stderr, "after glEndList()\n");
+ return false;
+ }
+
+ glCallList(dlist);
+ if (!piglit_check_gl_error(GL_NO_ERROR)) {
+ fprintf(stderr, "after glCallList()\n");
+ return false;
+ }
+
+ glDeleteLists(dlist, 1);
+
+ return true;
+}
+
+static bool
+run_tests(struct test *tests, int num_tests, GLenum expected_error)
+{
+ int i;
+ bool pass = true;
+
+ for (i = 0; i < num_tests; i++) {
+ bool test_pass = true;
+
+ printf("testing %s()\n", tests[i].name);
+ test_pass = test_pass &&
+ test_beginend(&tests[i], expected_error);
+
+ if (tests != nondlist_error_tests) {
+ test_pass = test_pass &&
+ test_dlist_compile(&tests[i], expected_error);
+ test_pass = test_pass &&
+ test_dlist_exec(&tests[i], expected_error);
+ test_pass = test_pass &&
+ test_dlist_compile_exec(&tests[i],
+ expected_error);
+
+ /* Sanity check that we can actually do our call in a
+ * display list without triggering an error (unless
+ * it's impossible)
+ */
+ if (tests != error_only_tests) {
+ test_pass = test_pass &&
+ test_dlist_compile_exec_after(&tests[i]);
+ }
+ }
+
+ piglit_report_subtest_result(test_pass ?
+ PIGLIT_PASS : PIGLIT_FAIL,
+ tests[i].name);
+
+ pass = test_pass && pass;
+ }
+
+ return pass;
+}
+
+/**
+ * Special-case testing for glEndList().
+ *
+ * If we call glEndList without a glNewList active, we will get
+ * GL_INVALID_OPERATION anyway. If we call glNewList in our begin/end
+ * block, then we have a GL_INVALID_OPERATION from that. So, to test
+ * glEndList() throwing GL_INVALID_OPERATION inside a begin/end
+ * specifically because it's inside a begin/end, we need the begin/end
+ */
+bool
+test_endlist()
+{
+ GLuint dlist;
+
+ if (!test_beginend(&endlist_test, GL_INVALID_OPERATION))
+ return false;
+
+ /* We can't use test_dlist_compile_exec because that expects
+ * the command to be compiled. We also need to distinguish
+ * the EndList inside the Begin/End failing like it's supposed
+ * to, from the one that's supposed to terminate the list
+ * failing in case the one inside Begin/End happened to
+ * execute.
+ */
+ printf(" Testing glNewList(GL_COMPILE_AND_EXEC) with begin/end "
+ "inside\n");
+
+ dlist = glGenLists(1);
+ glNewList(dlist, GL_COMPILE_AND_EXECUTE);
+ glBegin(GL_POINTS);
+ glEndList();
+ glEnd();
+ if (!piglit_check_gl_error(GL_INVALID_OPERATION)) {
+ fprintf(stderr, "after glEnd()\n");
+ return false;
+ }
+ glEndList();
+
+ return true;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ bool pass;
+
+ /* Set up some state to be used by our various test
+ * functions
+ */
+ newlist_dlist = glGenLists(1);
+ deletelists_dlist = glGenLists(1);
+
+ some_dlist = glGenLists(1);
+ glNewList(some_dlist, GL_COMPILE);
+ glEndList();
+
+ if (piglit_use_fbo)
+ fbo_attachment = GL_COLOR_ATTACHMENT0;
+ else
+ fbo_attachment = GL_FRONT;
+
+ pass = run_tests(ok_tests, ARRAY_SIZE(ok_tests), GL_NO_ERROR);
+ pass = run_tests(error_tests, ARRAY_SIZE(error_tests),
+ GL_INVALID_OPERATION) && pass;
+ pass = run_tests(error_only_tests, ARRAY_SIZE(error_only_tests),
+ GL_INVALID_OPERATION) && pass;
+
+ if (test_endlist()) {
+ piglit_report_subtest_result(PIGLIT_PASS, "glEndList");
+ } else {
+ piglit_report_subtest_result(PIGLIT_FAIL, "glEndList");
+ pass = false;
+ }
+
+ piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
+}
--
1.7.10.4
More information about the Piglit
mailing list