[Piglit] [PATCH 2/7] arb_vertex_attrib_binding: Test new states
Fredrik Höglund
fredrik at kde.org
Thu Jul 11 21:16:17 PDT 2013
Test setting and quering all new states. This also tests interactions
with glVertexAttribPointer().
---
tests/all.tests | 1 +
.../arb_vertex_attrib_binding/CMakeLists.gl.txt | 1 +
tests/spec/arb_vertex_attrib_binding/get.c | 432 ++++++++++++++++++++
3 files changed, 434 insertions(+)
create mode 100644 tests/spec/arb_vertex_attrib_binding/get.c
diff --git a/tests/all.tests b/tests/all.tests
index 42ff70c..b0772e0 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -1393,6 +1393,7 @@ arb_vertex_array_object['isvertexarray'] = concurrent_test('arb_vertex_array-isv
arb_vertex_attrib_binding = Group()
spec['ARB_vertex_attrib_binding'] = arb_vertex_attrib_binding
arb_vertex_attrib_binding['errors'] = concurrent_test('arb_vertex_attrib_binding-errors')
+arb_vertex_attrib_binding['get'] = concurrent_test('arb_vertex_attrib_binding-get')
arb_vertex_buffer_object = Group()
spec['ARB_vertex_buffer_object'] = arb_vertex_buffer_object
diff --git a/tests/spec/arb_vertex_attrib_binding/CMakeLists.gl.txt b/tests/spec/arb_vertex_attrib_binding/CMakeLists.gl.txt
index ebc0cc3..bd534ae 100644
--- a/tests/spec/arb_vertex_attrib_binding/CMakeLists.gl.txt
+++ b/tests/spec/arb_vertex_attrib_binding/CMakeLists.gl.txt
@@ -10,5 +10,6 @@ link_libraries (
)
piglit_add_executable (arb_vertex_attrib_binding-errors errors.c)
+piglit_add_executable (arb_vertex_attrib_binding-get get.c)
# vim: ft=cmake:
diff --git a/tests/spec/arb_vertex_attrib_binding/get.c b/tests/spec/arb_vertex_attrib_binding/get.c
new file mode 100644
index 0000000..bbe6793
--- /dev/null
+++ b/tests/spec/arb_vertex_attrib_binding/get.c
@@ -0,0 +1,432 @@
+/*
+ * Copyright © 2013 Fredrik Höglund
+ *
+ * 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 get.c
+ *
+ * Tests that setting and quering new state in GL_ARB_vertex_attrib_binding
+ * works as expected.
+ */
+
+#include "piglit-util-gl-common.h"
+
+#define MIN(a, b) (a < b ? a : b)
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_compat_version = 10;
+
+ config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+enum piglit_result
+piglit_display(void)
+{
+ /* uncreached */
+ return PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+ GLint value, maxBindings, maxAttribs;
+ GLuint buf, vao;
+ GLvoid *ptr = 0;
+ int i;
+
+ /* Require GL 3.0 for glGetIntegeri_v() */
+ piglit_require_gl_version(30);
+ piglit_require_extension("GL_ARB_vertex_attrib_binding");
+ piglit_require_extension("GL_ARB_vertex_array_bgra");
+ piglit_require_extension("GL_ARB_vertex_type_2_10_10_10_rev");
+ piglit_require_extension("GL_ARB_ES2_compatibility");
+
+ /* Create and bind a vertex array object */
+ glGenVertexArrays(1, &vao);
+ glBindVertexArray(vao);
+
+ /* Check limits */
+ glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribs);
+ if (maxAttribs < 16) {
+ fprintf(stderr, "GL_MAX_VERTEX_ATTRIBS must be at least 16");
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &maxBindings);
+ if (maxBindings < 16) {
+ fprintf(stderr, "GL_MAX_VERTEX_ATTRIB_BINDINGS must be at least 16");
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetIntegerv(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET, &value);
+ if (value < 2047) {
+ fprintf(stderr, "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET must be at least 2047");
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+
+ /* Check the initial values of the attrib properties */
+ for (i = 0; i < maxAttribs; i++) {
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_BINDING, &value);
+ if (value != i) {
+ fprintf(stderr, "Initial value of GL_VERTEX_ATTRIB_BINDING[%d] should be %d, was %d\n", i, i, value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, &value);
+ if (value != 0) {
+ fprintf(stderr, "Initial value of GL_VERTEX_ATTRIB_RELATIVE_OFFSET[%d] should be 0, was %d\n", i, value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+
+
+ /* Check the initial values of the binding properties */
+ for (i = 0; i < maxBindings; i++) {
+ glGetIntegeri_v(GL_VERTEX_BINDING_OFFSET, i, &value);
+ if (value != 0) {
+ fprintf(stderr, "Initial value of GL_VERTEX_BINDING_OFFSET[%d] should be 0, was %d\n", i, value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetIntegeri_v(GL_VERTEX_BINDING_STRIDE, i, &value);
+ if (value != 16) {
+ fprintf(stderr, "Initial value of GL_VERTEX_BINDING_STRIDE[%d] should be 16, was %d\n", i, value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetIntegeri_v(GL_VERTEX_BINDING_DIVISOR, i, &value);
+ if (value != 0) {
+ fprintf(stderr, "Initial value of GL_VERTEX_BINDING_DIVISOR[%d] should be 0, was %d\n", i, value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+
+
+ /* Create a buffer object */
+ glGenBuffers(1, &buf);
+ glBindBuffer(GL_ARRAY_BUFFER, buf);
+
+ /* Bind the buffer object to binding point 0, offset=1024, stride=32 */
+ glBindVertexBuffer(0, buf, 1024, 32);
+
+ glGetIntegeri_v(GL_VERTEX_BINDING_OFFSET, 0, &value);
+ if (value != 1024) {
+ fprintf(stderr, "GL_VERTEX_BINDING_OFFSET[0] was %d, expected 1024\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetIntegeri_v(GL_VERTEX_BINDING_STRIDE, 0, &value);
+ if (value != 32) {
+ fprintf(stderr, "GL_VERTEX_BINDING_STRIDE[0] was %d, expected 32\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* GL_VERTEX_ATTRIB_ARRAY_STRIDE should be unaffected */
+ glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &value);
+ if (value != 0) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_STRIDE[0] was %d, expected 0\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* Note: We can only query the buffer name indirectly through an attrib bound to the binding point */
+ glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &value);
+ if (value != buf) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING[0] was %d, expected %d\n", value, buf);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* GL_VERTEX_ATTRIB_ARRAY_POINTER should be unaffected by the offset */
+ glGetVertexAttribPointerv(0, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr);
+ if (ptr != NULL) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_POINTER[0] was %p, expected NULL\n", ptr);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+
+ /* Set the binding divisors and query the values */
+ for (i = 0; i < maxBindings; i++)
+ glVertexBindingDivisor(i, i);
+
+ for (i = 0; i < maxBindings; i++) {
+ glGetIntegeri_v(GL_VERTEX_BINDING_DIVISOR, i, &value);
+ if (value != i) {
+ fprintf(stderr, "GL_VERTEX_BINDING_DIVISOR[%d] was %d, expected %d\n", i, value, i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+
+ /* Check that the binding divisor is also reflected in GL_VERTEX_ATTRIB_ARRAY_DIVISOR */
+ for (i = 0; i < MIN(maxBindings, maxAttribs); i++) {
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, &value);
+ if (value != i) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_DIVISOR[%d] was %d, expected %d\n", i, value, i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+
+ /* Set the GL_VERTEX_ATTRIB_BINDING to 0 in all arrays and check the values */
+ for (i = 0; i < maxAttribs; i++)
+ glVertexAttribBinding(i, 0);
+
+ for (i = 0; i < maxAttribs; i++) {
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_BINDING, &value);
+ if (value != 0) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_BINDING[%d] was %d, expected 0\n", i, value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+
+
+ /* Test glVertexAttribFormat */
+ {
+ struct {
+ GLuint size;
+ GLenum type;
+ GLboolean normalized;
+ } formats[] = {
+ { 1, GL_BYTE, GL_TRUE },
+ { 2, GL_UNSIGNED_BYTE, GL_TRUE },
+ { 3, GL_SHORT, GL_TRUE },
+ { 4, GL_UNSIGNED_SHORT, GL_TRUE },
+ { 1, GL_INT, GL_FALSE },
+ { 2, GL_UNSIGNED_INT, GL_FALSE },
+ { 3, GL_FIXED, GL_FALSE },
+ { 4, GL_FLOAT, GL_FALSE },
+ { 1, GL_HALF_FLOAT, GL_FALSE },
+ { 2, GL_DOUBLE, GL_FALSE },
+ { 4, GL_INT_2_10_10_10_REV, GL_TRUE },
+ { 4, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE },
+ { GL_BGRA, GL_UNSIGNED_BYTE, GL_TRUE },
+ { GL_BGRA, GL_INT_2_10_10_10_REV, GL_TRUE },
+ { GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE }
+ };
+
+ for (i = 0; i < maxAttribs; i++)
+ glVertexAttribFormat(i, formats[i % 15].size, formats[i % 15].type, formats[i % 15].normalized, i);
+
+ for (i = 0; i < maxAttribs; i++) {
+ const GLuint size = formats[i % 15].size == GL_BGRA ? 4 : formats[i % 15].size;
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, &value);
+ if (value != i) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_RELATIVE_OFFSET[%d] was %d, expected %d\n", i, value, i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_SIZE, &value);
+ if (value != size) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_SIZE[%d] was %d, expected %d\n", i, value, size);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_TYPE, &value);
+ if (value != formats[i % 15].type) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_TYPE[%d] was %s, expected %s\n", i,
+ piglit_get_gl_enum_name(value),
+ piglit_get_gl_enum_name(formats[i % 15].type));
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &value);
+ if (value != formats[i % 15].normalized) {
+ if (value == GL_TRUE)
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED[%d] was GL_TRUE, expected GL_FALSE\n", i);
+ else
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED[%d] was GL_FALSE, expected GL_TRUE\n", i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_INTEGER, &value);
+ if (value != GL_FALSE) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_INTEGER[%d] was GL_TRUE, expected GL_FALSE\n", i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribPointerv(i, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr);
+ if (ptr != NULL) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_POINTER[%d] was %p, expected NULL\n", i, ptr);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+ }
+
+
+ /* Test glVertexAttribIFormat */
+ {
+ struct {
+ GLuint size;
+ GLenum type;
+ } formats[] = {
+ { 1, GL_BYTE },
+ { 2, GL_UNSIGNED_BYTE },
+ { 3, GL_SHORT },
+ { 4, GL_UNSIGNED_SHORT },
+ { 1, GL_INT },
+ { 2, GL_UNSIGNED_INT }
+ };
+
+ for (i = 0; i < maxAttribs; i++)
+ glVertexAttribIFormat(i, formats[i % 6].size, formats[i % 6].type, maxAttribs - i);
+
+ for (i = 0; i < maxAttribs; i++) {
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, &value);
+ if (value != maxAttribs - i) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_RELATIVE_OFFSET[%d] was %d, expected %d\n", i, value,
+ maxAttribs - i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_SIZE, &value);
+ if (value != formats[i % 6].size) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_SIZE[%d] was %d, expected %d\n", i, value,
+ formats[i % 6].size);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_TYPE, &value);
+ if (value != formats[i % 6].type) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_TYPE[%d] was %s, expected %s\n", i,
+ piglit_get_gl_enum_name(value),
+ piglit_get_gl_enum_name(formats[i % 6].type));
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_INTEGER, &value);
+ if (value != GL_TRUE) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_INTEGER[%d] was GL_FALSE, expected GL_TRUE\n", i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribPointerv(i, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr);
+ if (ptr != NULL) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_POINTER[%d] was %p, expected NULL\n", i, ptr);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+ }
+
+
+ /* Test glVertexAttribLFormat */
+ for (i = 0; i < maxAttribs; i++)
+ glVertexAttribLFormat(i, i % 3 + 1, GL_DOUBLE, i);
+
+ for (i = 0; i < maxAttribs; i++) {
+ int size = i % 3 + 1;
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, &value);
+ if (value != i) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_RELATIVE_OFFSET[%d] was %d, expected %d\n", i, value, i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_SIZE, &value);
+ if (value != size) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_SIZE[%d] was %d, expected %d\n", i, value, size);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_TYPE, &value);
+ if (value != GL_DOUBLE) {
+ const char *name = piglit_get_gl_enum_name(value);
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_TYPE[%d] was %s, expected GL_DOUBLE\n", i, name);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribPointerv(i, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr);
+ if (ptr != NULL) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_POINTER[%d] was %p, expected NULL\n", i, ptr);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_INTEGER, &value);
+ if (value != GL_FALSE) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_INTEGER[%d] was GL_TRUE, expected GL_FALSE\n", i);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+ }
+
+ /* Test interaction with glVertexAttribPointer */
+ glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (const GLfloat *) 0xdeadcafe);
+
+ /* glVertexAttribPointer() should reset the attrib binding to 1 */
+ glGetVertexAttribiv(1, GL_VERTEX_ATTRIB_BINDING, &value);
+ if (value != 1) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_BINDING[1] was %d, expected 1\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* The relative offset should be set to zero */
+ glGetVertexAttribiv(1, GL_VERTEX_ATTRIB_RELATIVE_OFFSET, &value);
+ if (value != 0) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_RELATIVE_OFFSET[1] was %d, expected 0\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* The binding offset should be set to the value of the address passed to glVertexAttribPointer() */
+ glGetIntegeri_v(GL_VERTEX_BINDING_OFFSET, 1, &value);
+ if (value != 0xdeadcafe) {
+ fprintf(stderr, "GL_VERTEX_BINDING_OFFSET[1] was %#x, expected 0xdeadcafe\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* The binding stride should be set to size * sizeof(float) = 16 */
+ glGetIntegeri_v(GL_VERTEX_BINDING_STRIDE, 1, &value);
+ if (value != 16) {
+ fprintf(stderr, "GL_VERTEX_BINDING_STRIDE[1] was %d, expected 16\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* GL_VERTEX_ATTRIB_ARRAY_STRIDE should be zero, since this is the value that was passed in */
+ glGetVertexAttribiv(1, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &value);
+ if (value != 0) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_STRIDE[1] was %d, expected 0\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ glBindVertexBuffer(1, buf, 1024, 32);
+
+ /* Verify that setting the offset didn't affect the GL_VERTEX_ATTRIB_ARRAY_POINTER value */
+ glGetVertexAttribPointerv(1, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr);
+ if (ptr != (const GLvoid *) 0xdeadcafe) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_POINTER[1] was %p, expected 0xdeadcafe\n", ptr);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* GL_VERTEX_BINDING_STRIDE should be set to the new value (32) */
+ glGetIntegeri_v(GL_VERTEX_BINDING_STRIDE, 1, &value);
+ if (value != 32) {
+ fprintf(stderr, "GL_VERTEX_BINDING_STRIDE[1] was %d, expected 32\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ /* GL_VERTEX_ATTRIB_ARRAY_STRIDE should still be zero */
+ glGetVertexAttribiv(1, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &value);
+ if (value != 0) {
+ fprintf(stderr, "GL_VERTEX_ATTRIB_ARRAY_STRIDE[1] was %d, expected 0\n", value);
+ piglit_report_result(PIGLIT_FAIL);
+ }
+
+ piglit_report_result(PIGLIT_PASS);
+}
--
1.7.10.4
More information about the Piglit
mailing list