Add test glsl-uniform-out-of-bounds-2.c

Check for consistent reporting of active array elements from
glGetActiveUniform and glGetUniformLocation, and check for correct
error reporting when reading/writing bogus uniform locations.

v2: Reorganized code, new comments and messages to make clearer.
    Adopt reviewer's suggestions about ARRAY_SIZE, formatting,
    piglit_check_gl_error, window size.
v3: Made concurrent, removed write/read/verify uniform test, and
    renamed variables per reviewer comments.
v4: Fixed up remaining style nits, expand a comment (by anholt)

3 files changed, 164 insertions, 0 deletions

diff --git a/tests/all.tests b/tests/all.tests
index b35356eb9..4581edf01 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -240,6 +240,7 @@ add_plain_test(shaders, 'glsl-novertexdata')
 add_plain_test(shaders, 'glsl-preprocessor-comments')
 add_plain_test(shaders, 'glsl-reload-source')
 add_plain_test(shaders, 'glsl-uniform-out-of-bounds')
+add_concurrent_test(shaders, 'glsl-uniform-out-of-bounds-2')
 add_plain_test(shaders, 'glsl-uniform-update')
 add_plain_test(shaders, 'glsl-unused-varying')
 add_plain_test(shaders, 'glsl-fs-bug25902')
diff --git a/tests/shaders/CMakeLists.gl.txt b/tests/shaders/CMakeLists.gl.txt
index 6ac023007..93cbf7b33 100644
--- a/tests/shaders/CMakeLists.gl.txt
+++ b/tests/shaders/CMakeLists.gl.txt
@@ -66,6 +66,7 @@ piglit_add_executable (glsl-reload-source glsl-reload-source.c)
 piglit_add_executable (glsl-unused-varying glsl-unused-varying.c)
 piglit_add_executable (glsl-uniform-update glsl-uniform-update.c)
 piglit_add_executable (glsl-uniform-out-of-bounds glsl-uniform-out-of-bounds.c)
+piglit_add_executable (glsl-uniform-out-of-bounds-2 glsl-uniform-out-of-bounds-2.c)
 piglit_add_executable (glsl-fs-bug25902 glsl-fs-bug25902.c)
 piglit_add_executable (glsl-fs-color-matrix glsl-fs-color-matrix.c)
 piglit_add_executable (glsl-fs-exp2 glsl-fs-exp2.c)
diff --git a/tests/shaders/glsl-uniform-out-of-bounds-2.c b/tests/shaders/glsl-uniform-out-of-bounds-2.c
new file mode 100644
index 000000000..fa50bb54c
--- /dev/null
+++ b/tests/shaders/glsl-uniform-out-of-bounds-2.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/**
+ * \file glsl-uniform-out-of-bounds-2.c
+ *
+ * glGetUniformLocation should return:
+ * -1 for inactive array elements (as reported by glGetActiveUniform)
+ * not -1 for active array elements (as reported by glGetActiveUniform)
+ * -1 for non-existent array elements (indices outside the array)
+ *
+ * Write and read some invalid locations and check for GL_INVALID_OPERATION.
+ *
+ * \author Frank Henigman <fjhenigman@google.com>
+ */
+
+#include "piglit-util-gl-common.h"
+
+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)
+{
+	/* unreached */
+	return PIGLIT_FAIL;
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+	GLint prog;
+	GLint vs, fs;
+	int i, j, k;
+	bool pass = true;
+	GLint num_active_uniform;
+	GLint min = -1, max = -1;
+	GLint bogus[99];
+	int num_bogus = 0;
+
+	piglit_require_gl_version(20);
+
+	vs = piglit_compile_shader_text(GL_VERTEX_SHADER,
+		"attribute vec4 p;\n"
+		"void main() { gl_Position = p; }\n"
+	);
+	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER,
+		"uniform vec4 v[4];\n"
+		"uniform mat4 m[4];\n"
+		"void main() { gl_FragColor = v[1] + m[1][1]; }\n"
+	);
+
+	prog = piglit_link_simple_program(vs, fs);
+	glUseProgram(prog);
+	glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num_active_uniform);
+	printf("active uniforms %d\n", num_active_uniform);
+
+	/* for each array in shader */
+	for (k = 0; k < num_active_uniform; ++k) {
+		GLchar name[99];
+		GLint num_active_elements;
+		GLenum type;
+		glGetActiveUniform(prog, k, ARRAY_SIZE(name), NULL,
+				   &num_active_elements,
+				   &type, name);
+		if (!((name[0] == 'v' || name[0] == 'm') && name[1] == 0))
+			continue;
+		printf("array '%s' active elements %d\n",
+		       name, num_active_elements);
+
+		/* for each index in array, plus some before and after */
+		for (i = -2; i < 6; ++i) {
+			bool is_active = 0 <= i && i < num_active_elements;
+			GLchar element[9];
+			GLint loc;
+			sprintf(element, "%s[%d]", name, i);
+			loc = glGetUniformLocation(prog, element);
+
+			/* does glGetUniformLocation agree with
+			 * glGetActiveUniform?
+			 */
+			if (loc == -1) {
+				if (is_active) {
+					printf("FAIL: no location for "
+					       "active %s\n", element);
+					pass = false;
+				}
+			} else {
+				if (!is_active) {
+					printf("FAIL: got location for "
+					       "inactive %s\n", element);
+					pass = false;
+				}
+
+				/* keep track of location min/max so
+				 * we can pick some locations to test
+				 * that we know aren't available.
+				 */
+				if (min == -1 || loc < min)
+					min = loc;
+				if (max == -1 || loc > max)
+					max = loc;
+			}
+		}
+	}
+
+	// make up some bogus locations
+	for (i = 1; i < 6; ++i) {
+		bogus[num_bogus++] = min - i;
+		bogus[num_bogus++] = max + i;
+		/* mesa encodes the uniform variable in the upper 16
+		 * bits of a location and puts the array index in the
+		 * lower 16
+		 */
+		bogus[num_bogus++] = max + (1<<16) + i - 3;
+	}
+
+	/* test writing and reading bogus locations */
+	for (i = 0; i < num_bogus; ++i) {
+		GLfloat v[16];
+		if (bogus[i] == -1)
+			continue;
+		printf("trying bogus location %d\n", bogus[i]);
+		glUniform4fv(bogus[i], 1, v);
+		if (!piglit_check_gl_error(GL_INVALID_OPERATION)) {
+			printf("FAIL: wrote vector to bogus location\n");
+			pass = false;
+		}
+		glUniformMatrix4fv(bogus[i], 1, GL_FALSE, v);
+		if (!piglit_check_gl_error(GL_INVALID_OPERATION)) {
+			printf("FAIL: wrote matrix to bogus location\n");
+			pass = false;
+		}
+		glGetUniformfv(prog, bogus[i], v);
+		if (!piglit_check_gl_error(GL_INVALID_OPERATION)) {
+			printf("FAIL: read from bogus location\n");
+			pass = false;
+		}
+	}
+
+	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
+}