[Piglit] [PATCH] Porting basic GL rendering tests to piglit
Ilia Mirkin
imirkin at alum.mit.edu
Tue Sep 1 15:17:39 PDT 2015
On Tue, Sep 1, 2015 at 5:49 PM, Juliet Fru <julietfru at gmail.com> wrote:
> ---
> tests/all.py | 1 +
> tests/spec/gl-1.0/CMakeLists.gl.txt | 1 +
> tests/spec/gl-1.0/no-op-paths.c | 332 ++++++++++++++++++++++++++++++++++++
> 3 files changed, 334 insertions(+)
> create mode 100644 tests/spec/gl-1.0/no-op-paths.c
>
> diff --git a/tests/all.py b/tests/all.py
> index fcfc5cd..85973d6 100644
> --- a/tests/all.py
> +++ b/tests/all.py
> @@ -1000,6 +1000,7 @@ with profile.group_manager(
> g(['gl-1.0-ortho-pos'])
> g(['gl-1.0-readpixsanity'])
> g(['gl-1.0-logicop'])
> + g(['gl-1.0-no-op-paths'])
>
> with profile.group_manager(
> PiglitGLTest,
> diff --git a/tests/spec/gl-1.0/CMakeLists.gl.txt b/tests/spec/gl-1.0/CMakeLists.gl.txt
> index d04b835..7a7f508 100644
> --- a/tests/spec/gl-1.0/CMakeLists.gl.txt
> +++ b/tests/spec/gl-1.0/CMakeLists.gl.txt
> @@ -22,6 +22,7 @@ piglit_add_executable (gl-1.0-front-invalidate-back front-invalidate-back.c)
> piglit_add_executable (gl-1.0-logicop logicop.c)
> piglit_add_executable (gl-1.0-long-dlist long-dlist.c)
> piglit_add_executable (gl-1.0-ortho-pos orthpos.c)
> +piglit_add_executable (gl-1.0-no-op-paths no-op-paths.c)
> piglit_add_executable (gl-1.0-polygon-line-aa polygon-line-aa.c)
> piglit_add_executable (gl-1.0-push-no-attribs push-no-attribs.c)
> piglit_add_executable (gl-1.0-readpixsanity readpix.c)
> diff --git a/tests/spec/gl-1.0/no-op-paths.c b/tests/spec/gl-1.0/no-op-paths.c
> new file mode 100644
> index 0000000..ea4abf5
> --- /dev/null
> +++ b/tests/spec/gl-1.0/no-op-paths.c
> @@ -0,0 +1,332 @@
> +/* BEGIN_COPYRIGHT -*- glean -*-
> + *
> + * Copyright (C) 1999 Allen Akin All Rights Reserved.
> + * Copyright (C) 2015 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.
> + *
> + * END_COPYRIGHT
> + */
> +/** @file paths.c
> + *
> + * Test basic GL rendering paths.
> + *
> + *
> + * Based on the original Glean tpaths.cpp test, this test verifies
> + * that basic, trival OpenGL paths work as expected. For example,
> + * glAlphaFunc(GL_GEQUAL, 0.0) should always pass and
> + * glAlphaFunc(GL_LESS, 0.0) should always fail. We setup trivial
> + * pass and fail conditions for each of alpha test, blending, color mask,
> + * depth test, logic ops, scissor, stencil, stipple, and texture and
> + * make sure they work as expected. We also setup trival-pass for all
> + * these paths simultaneously and test that as well.
> + *
> + * To test for pass/fail we examine the color buffer for white or black,
> + * respectively.
> + *
> + * Authors:
> + * Brian Paul <brianp at valinux.com>
> + * Adapted to Piglit by Juliet Fru <julietfru at gmail.com>, August 2015.
> + */
> +
> +#include "piglit-util-gl.h"
> +
> +PIGLIT_GL_TEST_CONFIG_BEGIN
> +
> + config.supports_gl_compat_version = 10;
> +
> + config.window_visual = PIGLIT_GL_VISUAL_RGBA |
> + PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_DEPTH;
> +
> +PIGLIT_GL_TEST_CONFIG_END
> +
> +enum path {
> + ALPHA,
> + BLEND,
> + COLOR_MASK,
> + DEPTH,
> + LOGIC,
> + SCISSOR,
> + STENCIL,
> + STIPPLE,
> + TEXTURE,
> + ZZZ /* end-of-list token */
> +};
> +
> +enum state{
Missing space
> + DISABLE,
> + ALWAYS_PASS,
> + ALWAYS_FAIL
> +};
> +
> +const char *
static
> +path_name(enum path paths)
> +{
> + switch (paths) {
> + case ALPHA:
> + return "Alpha Test";
> + case BLEND:
> + return "Blending";
> + case COLOR_MASK:
> + return "Color Mask";
> + case DEPTH:
> + return "Depth Test";
> + case LOGIC:
> + return "LogicOp";
> + case SCISSOR:
> + return "Scissor Test";
> + case STENCIL:
> + return "Stencil Test";
> + case STIPPLE:
> + return "Polygon Stipple";
> + case TEXTURE:
> + return "Modulated Texture";
> + case ZZZ:
> + return "paths";
> + }
> +}
> +
> +void
static
> +set_path_state(enum path paths, enum state states)
> +{
> + int i;
> + switch (paths) {
> + case ALPHA:
> + if (states == ALWAYS_PASS) {
> + glAlphaFunc(GL_GEQUAL, 0.0);
> + glEnable(GL_ALPHA_TEST);
> + }
> + else if (states == ALWAYS_FAIL) {
> + glAlphaFunc(GL_GREATER, 1.0);
> + glEnable(GL_ALPHA_TEST);
> + }
> + else {
> + glDisable(GL_ALPHA_TEST);
> + }
> + break;
> + case BLEND:
> + if (states == ALWAYS_PASS) {
> + glBlendFunc(GL_ONE, GL_ZERO);
> + glEnable(GL_BLEND);
> + }
> + else if (states == ALWAYS_FAIL) {
> + glBlendFunc(GL_ZERO, GL_ONE);
> + glEnable(GL_BLEND);
> + }
> + else {
> + glDisable(GL_BLEND);
> + }
> + break;
> + case COLOR_MASK:
> + if (states == ALWAYS_PASS) {
> + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
> + }
> + else if (states == ALWAYS_FAIL) {
> + glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
> + }
> + else {
> + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
> + }
> + break;
> + case DEPTH:
> + if (states == ALWAYS_PASS) {
> + glDepthFunc(GL_ALWAYS);
> + glEnable(GL_DEPTH_TEST);
> + }
> + else if (states == ALWAYS_FAIL) {
> + glDepthFunc(GL_NEVER);
> + glEnable(GL_DEPTH_TEST);
> + }
> + else {
> + glDisable(GL_DEPTH_TEST);
> + }
> + break;
> + case LOGIC:
> + if (states == ALWAYS_PASS) {
> + glLogicOp(GL_OR);
> + glEnable(GL_COLOR_LOGIC_OP);
> + }
> + else if (states == ALWAYS_FAIL) {
> + glLogicOp(GL_AND);
> + glEnable(GL_COLOR_LOGIC_OP);
> + }
> + else {
> + glDisable(GL_COLOR_LOGIC_OP);
> + }
> + break;
> + case SCISSOR:
> + if (states == ALWAYS_PASS) {
> + glScissor(0, 0, 10, 10);
> + glEnable(GL_SCISSOR_TEST);
> + }
> + else if (states == ALWAYS_FAIL) {
> + glScissor(0, 0, 0, 0);
> + glEnable(GL_SCISSOR_TEST);
> + }
> + else {
> + glDisable(GL_SCISSOR_TEST);
> + }
> + break;
> + case STENCIL:
> + if (states == ALWAYS_PASS) {
> + /* pass if reference <= stencil value (ref = 0) */
> + glStencilFunc(GL_LEQUAL, 0, ~0);
> + glEnable(GL_STENCIL_TEST);
> + }
> + else if (states == ALWAYS_FAIL) {
> + /* pass if reference > stencil value (ref = 0) */
> + glStencilFunc(GL_GREATER, 0, ~0);
> + glEnable(GL_STENCIL_TEST);
> + }
> + else {
> + glDisable(GL_STENCIL_TEST);
> + }
> + break;
> + case STIPPLE:
> + if (states == ALWAYS_PASS) {
> + GLubyte stipple[4*32];
> + for (i = 0; i < 4*32; i++)
> + stipple[i] = 0xff;
> + glPolygonStipple(stipple);
> + glEnable(GL_POLYGON_STIPPLE);
> + }
> + else if (states == ALWAYS_FAIL) {
> + GLubyte stipple[4*32];
> + for (i = 0; i < 4*32; i++)
> + stipple[i] = 0x0;
> + glPolygonStipple(stipple);
> + glEnable(GL_POLYGON_STIPPLE);
> + }
> + else {
> + glDisable(GL_POLYGON_STIPPLE);
> + }
> + break;
> + case TEXTURE:
> + if (states == DISABLE) {
> + glDisable(GL_TEXTURE_2D);
> + }
> + else {
> + GLubyte val = (states == ALWAYS_PASS) ? 0xff : 0x00;
> + GLubyte texImage[4*4*4];
> + for (i = 0; i < 4*4*4; i++)
> + texImage[i] = val;
> + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0,
> + GL_RGBA, GL_UNSIGNED_BYTE, texImage);
> + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
> + GL_NEAREST);
> + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
> + GL_NEAREST);
> + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
> + GL_MODULATE);
> + glEnable(GL_TEXTURE_2D);
> + }
> + break;
> + default:
> + break;
> + }
> +}
> +
> +void
> +piglit_init(int argc, char **argv)
> +{
> + /* No init */
> +}
> +
> +enum piglit_result
> +piglit_display(void)
> +{
> + bool pass = true;
> + enum path p, paths[10];
> + int i, num_paths = 0;
> +
> + static const float white[3] = {1.0, 1.0, 1.0};
> +
> + /* draw 10x10 pixel quads */
> + glViewport(0, 0, 10, 10);
Perhaps you can improve this test while you're at it? Right now if one
thing fails, that's it the whole test fails and you have no idea if
anything down the line fails, or conversely if everything else is
alright and it's just that one thing.
Instead you could do something like
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
> +
> + glDisable(GL_DITHER);
> +
> + /* Build the list of paths to exercise */
> + for (p = ALPHA; p != ZZZ; p = (enum path) (p + 1)) {
> + paths[num_paths++] = p;
> + }
I'm a little confused what this adds. Why not just do
num_paths = ZZZ;
and then just use i instead of paths[i] everywhere?
> +
> + /* test always-pass paths */
> + for (i = 0; i < num_paths; i++) {
> + glClear(GL_COLOR_BUFFER_BIT);
> +
> + set_path_state(paths[i], ALWAYS_PASS);
> +
> + /* draw polygon */
> + piglit_draw_rect(-1, -1, 2, 2);
piglit_draw_rect(i * 10, 0, 10, 10);
> +
> +
> + set_path_state(paths[i], DISABLE);
> +
> + /* test buffer */
> + if (!piglit_probe_pixel_rgb(i * 10 + 4, 4, white)) {
pass = false;
> + piglit_present_results();
> + return PIGLIT_FAIL;
and remove that.
> + }
> + }
> +
> + /* enable all always-pass paths */
> + {
> + glClear(GL_COLOR_BUFFER_BIT);
> +
> + for (i = 0; i < num_paths; i++) {
> + set_path_state(paths[i], ALWAYS_PASS);
> + }
> +
> + /* draw polygon */
> + piglit_draw_rect(-1, -1, 2, 2);
piglit_draw_rect(10, 10, 10, 10);
> +
> + for (i = 0; i < num_paths; i++) {
> + set_path_state(paths[i], DISABLE);
> + }
> +
> + /* test buffer */
> + if (!piglit_probe_pixel_rgb(4, 4, white)) {
> + piglit_present_results();
> + return PIGLIT_FAIL;
> + }
> + }
> +
> + /* test never-pass paths */
> + for (i = 0; i < num_paths; i++) {
> + glClear(GL_COLOR_BUFFER_BIT);
> +
> + set_path_state(paths[i], ALWAYS_FAIL);
> +
> + /* draw polygon */
> + piglit_draw_rect(-1, -1, 2, 2);
piglit_draw_rect(10 * i, 20, 10, 10);
> +
> + set_path_state(paths[i], DISABLE);
> +
> + /* test buffer */
> + if (!piglit_probe_pixel_rgb(4, 4, white)) {
> + piglit_present_results();
> + return PIGLIT_FAIL;
> + }
> + }
> +
> + piglit_present_results();
> + return PIGLIT_PASS;
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
That way you should end up with all the fails even if only a few of
them fails in the middle.
> +}
> --
> 2.4.3
>
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
More information about the Piglit
mailing list