1677 files changed, 40474 insertions, 56842 deletions

diff --git a/framework/glsl_parser_test.py b/framework/glsl_parser_test.py
index 66e6dd36..7df78e23 100755
--- a/framework/glsl_parser_test.py
+++ b/framework/glsl_parser_test.py
@@ -21,12 +21,15 @@
 # OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
-"""This module enables the running of GLSL parser tests.
+"""This module enables the running of GLSL and GLSL ES parser tests.
 
 This module can be used to add parser tests to a Piglit test group or to run
-standalone tests on the command line. To add a test to a Piglit group, us
-``add_glsl_parser_test()``. To run a single standalone test, execute
+standalone tests on the command line. To add a test to a Piglit group, use
+``add_glsl_parser_test()``. To run a single standalone GLSL test, execute
 ``glsl_parser_test.py TEST_FILE``.
+To radd a test to the Piglit group for GLSL ES use
+``add_glsl_es_parser_test()``. To run a single standalone GLSL ES test,
+execute ``glsl_parser_test.py TEST_FILE es``.
 """
 
 usage_message = "usage: glsl_parser_test.py TEST_FILE"
@@ -47,6 +50,10 @@ def add_glsl_parser_test(group, filepath, test_name):
 	"""Add an instance of GLSLParserTest to the given group."""
 	group[test_name] = GLSLParserTest(filepath)
 
+def add_glsl_es_parser_test(group, filepath, test_name):
+	"""Add an instance of GLSLESParserTest to the given group."""
+	group[test_name] = GLSLESParserTest(filepath)
+
 def import_glsl_parser_tests(group, basepath, subdirectories):
 	"""
 	Recursively register each shader source file in the given
@@ -368,8 +375,14 @@ class GLSLParserTest(PlainExecTest):
 			return None
 
 		assert(self.config is not None)
+
+		if self.config.get('config', 'glsl_version') == '1.00':
+			runner = "glslparsertest_gles2"
+		else:
+			runner = "glslparsertest"
+
 		command = [
-			path.join(testBinDir, 'glslparsertest'),
+			path.join(testBinDir, runner),
 			self.__filepath,
 			self.config.get('config', 'expect_result'),
 			self.config.get('config', 'glsl_version')
@@ -383,12 +396,108 @@ class GLSLParserTest(PlainExecTest):
 	def env(self):
 		return dict()
 
+class GLSLESParserTest(GLSLParserTest):
+	"""Extend GLSLParserTest by adding support for GLSL ES
+
+	This extension takes a GLSL source file and passes it to
+	``glslparsertest_glesX`` where X is either 2 or 3 for GLES2 or
+	GLES3 respectively.
+
+	Config Section Extensions
+	-------------------------
+	The config section of the ``.vert``, or ``.frag`` is the same as
+	what is required for GLSLParserTest with the following extensions.
+
+	Required Option
+	---------------
+	glsles_version: A valid GLSL ES version number such as 1.00.
+
+	Nonrequired Option
+	------------------
+	glsles_expect_result: Either ``pass`` or ``fail``. If this
+		option is not specified expect_result will be used. This
+		option allows for GLSL and GLSL ES tests to have different
+		results and therefore reuse more testcases.
+
+	Examples
+	--------
+	::
+		// [config]
+		// glsl_version: 1.20
+		// glsl_version: 1.00
+		// expect_result: pass
+		// [end config]
+	::
+		/* [config]
+		 * glsl_version: 1.10
+		 * glsl_version: 1.00
+		 * expect_result: pass
+		 * glsles_expect_result: fail
+		 * [end config]
+		 */
+	"""
+
+	_GLSLParserTest__config_defaults = {
+		'require_extensions' : '',
+		'check_link' : 'false',
+		'glsles_expect_result' : 'ign',
+		'glsles_version' : '0.00'
+		}
+
+	@property
+	def command(self):
+		"""Command line arguments for 'glslparsertest_glesX'.
+
+		The command line arguments are constructed by parsing the
+		config section of the test file. If any errors are present in
+		the config section, then ``self.result`` is set to failure and
+		this returns ``None``.
+
+		:return: [str] or None
+		"""
+
+		if self.result is not None:
+			return None
+
+		assert(self.config is not None)
+
+		if self.config.get('config','glsles_version') == '0.00':
+			return None
+
+		if self.config.get('config','glsles_version') == '1.00':
+			commandstr='glslparsertest_gles2'
+		elif self.config.get('config','glsles_version') == '3.00':
+			commandstr='glslparsertest_gles3'
+
+		if self.config.get('config','glsles_expect_result') != 'ign':
+			resultstr=self.config.get('config','glsles_expect_result')
+		else:
+			resultstr=self.config.get('config', 'expect_result')
+
+		command = [
+			path.join(testBinDir, commandstr),
+			self._GLSLParserTest__filepath,
+			resultstr,
+			self.config.get('config', 'glsles_version')
+			]
+		if self.config.get('config', 'check_link').lower() == 'true':
+			command.append('--check-link')
+		command += self.config.get('config', 'require_extensions').split()
+		return command
+
 if __name__ == '__main__':
-	if len(sys.argv) != 2:
+	arglength=len(sys.argv)
+	if 3 > arglength < 2:
 		sys.stderr.write("{0}: usage error\n\n".format(sys.argv[0]))
 		sys.stderr.write(usage_message)
 	test_file = sys.argv[1]
-	test = GLSLParserTest(test_file)
+	if arglength == 2:
+		test = GLSLParserTest(test_file)
+	elif arglength == 3:
+		if sys.argv[2] == "es":
+			test = GLSLESParserTest(test_file)
+		else:
+			sys.stderr.write("{0}: usage error\n\n".format(sys.argv[0]))
 	test.run_standalone()
 
 # vim: noet ts=8 sw=8:
diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt
index 58ff0af6..ee7d419e 100644
--- a/generated_tests/CMakeLists.txt
+++ b/generated_tests/CMakeLists.txt
@@ -65,6 +65,24 @@ piglit_make_generated_tests(
 	builtin_cl_int_tests.list
 	generate-cl-int-builtins.py)
 piglit_make_sh_generated_tests(
+	variable-index-read-100_tests.list
+	variable-index-read.sh 1.00)
+piglit_make_sh_generated_tests(
+	variable-index-read-110_tests.list
+	variable-index-read.sh 1.10)
+piglit_make_sh_generated_tests(
+	variable-index-read-120_tests.list
+	variable-index-read.sh 1.20)
+piglit_make_sh_generated_tests(
+	variable-index-write-100_tests.list
+	variable-index-write.sh 1.00)
+piglit_make_sh_generated_tests(
+	variable-index-write-110_tests.list
+	variable-index-write.sh 1.10)
+piglit_make_sh_generated_tests(
+	variable-index-write-120_tests.list
+	variable-index-write.sh 1.20)
+piglit_make_sh_generated_tests(
 	outerProduct-invalid-parameters_tests.list
 	outerProduct-invalid-parameters.sh 3.00)
 
@@ -79,4 +97,10 @@ add_custom_target(gen-tests ALL
 		non-lvalue_tests.list
 		outerProduct-invalid-parameters_tests.list
 		texture_query_lod_tests.list
-		uniform-initializer_tests.list)
+		uniform-initializer_tests.list
+		variable-index-read-100_tests.list
+		variable-index-read-110_tests.list
+		variable-index-read-120_tests.list
+		variable-index-write-100_tests.list
+		variable-index-write-110_tests.list
+		variable-index-write-120_tests.list)
diff --git a/generated_tests/variable-index-read.sh b/generated_tests/variable-index-read.sh
new file mode 100755
index 00000000..1dd821a4
--- /dev/null
+++ b/generated_tests/variable-index-read.sh
@@ -0,0 +1,548 @@
+#!/bin/bash
+
+# Generate a set of data for a sized matrix.  Elements start with a specified
+# value and increment by 1.0 for each element.
+function matrix_data
+{
+    first=$1
+    dim=$2
+
+    last=$(($first + $dim * $dim - 1))
+    seq $first $last | tr '\n' ' ' | sed 's/ /.0, /g;s/, $//;s/ *$//g'
+}
+
+
+function emit_matrix_array_initializer
+{
+    matrix_dim=$1
+    array_dim=$2
+    base_type=$3
+    indent=$4
+
+    for c in $(seq $array_dim); do
+	if [ $c -ne 1 ]; then
+	    echo ","
+	fi
+
+	first=$(((c - 1) * matrix_dim * matrix_dim + 1))
+	echo -n "${indent}    ${base_type}("
+	matrix_data $first $matrix_dim
+	echo -n ")"
+    done
+
+}
+
+
+# Emit global variable declarations for either the vertex shader or the
+# fragment shader.
+function emit_globals
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col=$5
+    expect_type=$6
+
+    v=${version/./}
+    if [ $v -ge 120 ]; then
+	base_type="mat${matrix_dim}x${matrix_dim}"
+    else
+	base_type="mat${matrix_dim}"
+    fi
+
+    type=$base_type
+    dim=""
+    if [ $array_dim -ne 0 ]; then
+	if [ $v -ge 120 ]; then
+	    type="${type}[$array_dim]"
+	else
+	    dim="[${array_dim}]"
+	fi
+    fi
+
+    if [ $array_dim -ne 0 -a "x$index_value" = "xindex" ]; then
+	echo "uniform int index;"
+    fi
+
+    if [ "x$col" = "xcol" ]; then
+	echo "uniform int col;"
+    fi
+
+    if [ "x$expect_type" == "xfloat" ]; then
+	echo "uniform int row;"
+    fi
+
+    echo "uniform ${expect_type} expect;"
+
+    if [ $v -ge 120 -a "x$mode" = "xuniform" ]; then
+	if [ $array_dim -eq 0 ]; then
+            echo -n "${mode} ${type} m = ${type}("
+	    matrix_data 1 $matrix_dim
+	    echo ");"
+	else
+	    echo "${mode} ${type} m${dim} = ${type}("
+	    emit_matrix_array_initializer $matrix_dim $array_dim $base_type ""
+	    echo ");"
+	fi
+    elif [ "x$mode" != "xtemp" ]; then
+        echo "${mode} ${type} m${dim};"
+    fi
+    echo "varying vec4 color;"
+    echo
+}
+
+
+function emit_set_matrix
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+
+    v=${version/./}
+    if [ $v -ge 120 ]; then
+	base_type="mat${matrix_dim}x${matrix_dim}"
+    else
+	base_type="mat${matrix_dim}"
+    fi
+
+    type=$base_type
+    dim=""
+    if [ $array_dim -ne 0 ]; then
+	if [ $v -ge 120 ]; then
+	    type="${type}[$array_dim]"
+	else
+	    dim="[${array_dim}]"
+	fi
+    fi
+
+    if [ $array_dim -ne 0 ]; then
+	if [ "x$mode" = "xtemp" ]; then
+	    if [ $v -ge 120 ]; then
+		echo "    ${type} m${dim} = ${type}("
+		emit_matrix_array_initializer $matrix_dim $array_dim $base_type "    "
+		echo ");"
+	    else
+		echo "    ${type} m${dim};"
+	    fi
+	fi
+
+	if [ $v -lt 120 -o "x$mode" = "xvarying" ]; then
+	    for i in $(seq 0 $(($array_dim - 1))); do
+		first=$((1 + $i * $matrix_dim * $matrix_dim))
+		echo -n "    m[$i] = mat${matrix_dim}("
+		matrix_data $first $matrix_dim
+		echo ");"
+	    done
+	fi
+    else
+	matrix_values=$(matrix_data 1 $matrix_dim)
+
+	if [ "x$mode" = "xtemp" ] ; then
+	    echo "    ${type} m = ${type}(${matrix_values});"
+	else
+	    echo "    m = ${type}(${matrix_values});"
+	fi
+    fi
+}
+
+
+function emit_vs
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col=$5
+    expect_type=$6
+    do_compare=$7
+    v=${version/./}
+
+    if [ $array_dim -ne 0 ]; then
+	idx="[${index_value}]"
+    else
+	idx=""
+    fi
+
+    echo "[vertex shader]"
+    if [ $v -eq 100 ]; then
+        echo "attribute vec4 vertex;"
+        echo "mat4 projection = mat4("
+        echo "    2.0/250.0, 0.0, 0.0, -1.0,"
+        echo "    0.0, 2.0/250.0, 0.0, -1.0,"
+        echo "    0.0, 0.0, -1.0, 0.0,"
+        echo "    0.0, 0.0, 0.0, 1.0);"
+    fi
+    emit_globals $*
+
+    echo "void main()"
+    echo "{"
+    if [ $v -eq 100 ]; then
+        echo "    gl_Position = vertex;"
+        echo "    gl_Position *= projection;"
+    else
+        echo "    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
+    fi
+
+    # Only emit the code to set the matrix if the vertex shader is generating
+    # varyings for a fragment shader or the matrix is in local storage and the
+    # vertex shader is doing the comparison.
+    if [ "x$mode" = "xvarying" -o \( "x$mode" = "xtemp" -a  $do_compare -ne 0 \) ]; then
+	echo
+	emit_set_matrix $matrix_dim $array_dim $mode
+    fi
+
+    if [ $do_compare -ne 0 ]; then
+        # Many people thing that a vertex shader cannot read a varying.  Quote
+        # some bits from the GLSL spec so that people won't get the wrong idea
+        # when reading the test.
+	if [ "x$mode" = "xvarying" ]; then
+	    cat <<EOF
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+EOF
+	fi
+
+	if [ "x$expect_type" = "xfloat" ]; then
+	    echo "    color = (m${idx}[$col][row] == expect)"
+	else
+	    echo "    color = (m${idx}[$col] == expect)"
+	fi
+	echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
+    fi
+    echo -e "}\n"
+}
+
+
+emit_fs()
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col=$5
+    expect_type=$6
+    do_compare=$7
+    v=${version/./}
+
+    echo "[fragment shader]"
+    if [ $v -eq 100 ]; then
+        echo "precision highp float;"
+        echo "precision highp int;"
+    fi
+    emit_globals $*
+
+    echo "void main()"
+    echo "{"
+
+    if [ $do_compare -eq 0 -a "x$mode" = "xvarying" ]; then
+	cat <<EOF
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+EOF
+    fi
+
+    if [ $do_compare -ne 0 -o "x$mode" = "xvarying" ]; then
+	if [ "x$mode" = "xtemp" ]; then
+	    emit_set_matrix $matrix_dim $array_dim $mode
+	    echo
+	fi
+
+	if [ $array_dim -ne 0 ]; then
+	    idx="[$index_value]"
+	else
+	    idx=""
+	fi
+
+	if [ "x$expect_type" = "xfloat" ]; then
+	    row="[row]"
+	else
+	    row=""
+	fi
+
+	echo "    gl_FragColor = (m${idx}[${col}]${row} == expect)"
+
+	if [ $do_compare -eq 0 ]; then
+            echo "        ? color : vec4(1.0, 0.0, 0.0, 1.0);"
+	else
+            echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
+	fi
+    else
+	echo "    gl_FragColor = color;"
+    fi
+
+    echo "}"
+    echo
+}
+
+
+function emit_test_vectors
+{
+    matrix_dim=$1
+    local array_dim=$2
+    mode=$3
+    index_value=$4
+    col=$5
+    expect_type=$6
+    v=${version/./}
+
+    # Optimizing GLSL linkers may reduce the size of the uniform array if tail
+    # elements are not accessed.  Shader runner will fail the test if one of
+    # the set uniforms doesn't have a location.
+    if [ "x$mode" = "xuniform" -a $v -le 110 -a $array_dim -ne 0 -a "x$index_value" != "xindex" ]; then
+	array_dim=$((index_value+1))
+    fi
+
+    if [ "$v" -eq 100 ]; then
+        cat <<EOF
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+
+EOF
+    else
+        cat <<EOF
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+EOF
+    fi
+
+    # NOTE: shader_runner uses the matCxR names even for GLSL 1.10
+    type="mat${matrix_dim}x${matrix_dim}"
+    if [ "x$mode" = "xuniform" -a $v -le 110 ]; then
+	if [ $array_dim -eq 0 ]; then
+	    echo -n "uniform ${type} m "
+	    matrix_data 1 $matrix_dim | sed 's/,//g'
+	    echo
+	fi
+    fi
+
+    if [ $array_dim -eq 0 ]; then
+	sizes="1"
+    elif [ "x$index_value" = "xindex" ]; then
+	sizes=$(seq $array_dim)
+    else
+	sizes="2"
+    fi
+
+    if [ "x$col" = "xcol" ]; then
+	columns=$(seq $matrix_dim)
+    else
+	columns=2
+    fi
+
+    if [ "x$expect_type" = "xfloat" ]; then
+	rows=$(seq $matrix_dim)
+    else
+	rows=1
+    fi
+
+    for i in $sizes; do
+	if [ "x$mode" = "xuniform" -a $v -le 110 ]; then
+	    if [ $array_dim -ne 0 ]; then
+		for c in $(seq 0 $(($array_dim - 1))); do
+		    first=$((1 + c * matrix_dim * matrix_dim))
+		    echo -n "uniform ${type} m[$c] "
+		    matrix_data $first $matrix_dim | sed 's/,//g'
+		    echo
+		done
+	    fi
+	fi
+
+	if [ $array_dim -ne 0 -a "x$index_value" = "xindex" ]; then
+	    echo "uniform int index $((i - 1))"
+	fi
+
+	x_base=$(((i - 1) * (15 * matrix_dim + 10)))
+	for c in $columns; do
+	    if [ "x$col" = "xcol" ]; then
+		echo "uniform int col $((c - 1))"
+	    fi
+
+	    for r in $rows; do
+		expect=$(((i - 1) * (matrix_dim * matrix_dim) + (c - 1) * matrix_dim + r))
+		if [ "x$expect_type" = "xfloat" ]; then
+		    echo "uniform int row $((r - 1))"
+		    echo "uniform float expect $expect"
+		else
+		    e=$(seq $expect $((expect + matrix_dim - 1)) | tr '\n' ' ' | sed 's/[[:space:]]*$//g')
+		    echo "uniform ${expect_type} expect $e"
+		fi
+
+		x=$((x_base + 15 * c - 10))
+		y=$((15 * r - 10))
+		echo "draw rect $x $y 10 10"
+
+		x=$((x + 5))
+		y=$((y + 5))
+		echo "probe rgb $x $y 0.0 1.0 0.0"
+		echo
+	    done
+	done
+    done
+}
+
+# Generate a test that read from an (array of) matrix using a non-constant
+# index in the fragment shader.
+function emit_fs_rd_test
+{
+    v=${version/./}
+
+    echo "# Test generated by:"
+    echo "# ${cmd}"
+    echo
+    echo "[require]"
+    if [ $v -eq 100 ]; then
+        echo "GLSL ES >= $version"
+        echo "GL ES >= 2.0"
+    else
+        echo "GLSL >= $version"
+    fi
+    echo
+
+    emit_vs $* 0
+    emit_fs $* 1
+
+    emit_test_vectors $*
+}
+
+
+# Generate a test that read from an (array of) matrix using a non-constant
+# index in the fragment shader.
+function emit_vs_rd_test
+{
+    v=${version/./}
+
+    echo "# Test generated by:"
+    echo "# ${cmd}"
+    echo
+    echo "[require]"
+    if [ $v -eq 100 ]; then
+        echo "GLSL ES >= $version"
+        echo "GL ES >= 2.0"
+    else
+        echo "GLSL >= $version"
+    fi
+    echo
+
+    emit_vs $* 1
+    emit_fs $* 0
+
+    emit_test_vectors $*
+}
+
+cmd="$0 $*"
+
+if [ "x$1" = "x" ]; then
+    version="1.10"
+else
+    case "$1" in
+	1.[012]0) version="$1";;
+	*)
+	    echo "Bogus GLSL version \"$1\" specified."
+	    exit 1
+	    ;;
+    esac
+fi
+
+v=${version/./}
+if [ $v -eq 100 ]; then
+	es="-es"
+fi
+
+filepath="spec/glsl"${es}-${version}"/execution/varible-index-read"
+mkdir -p ${filepath}
+
+for mode in temp uniform varying; do
+    # More than 3 is unlikely to work for the varying tests due to using too
+    # many varying vectors.  mat4[3] uses 12 varying vectors by itself.
+    for array_dim in 0 3; do
+	for matrix_dim in 2 3 4; do
+	    if [ $array_dim -ne 0 ]; then
+		arr="array-"
+		idx_txt="index-"
+
+		emit_fs_rd_test $matrix_dim $array_dim $mode 1 col float \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-row-rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-row-rd.shader_test"
+
+		emit_fs_rd_test $matrix_dim $array_dim $mode 1 1   float \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-row-rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-row-rd.shader_test"
+
+		emit_fs_rd_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-rd.shader_test"
+
+		emit_fs_rd_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-rd.shader_test"
+
+		emit_vs_rd_test $matrix_dim $array_dim $mode 1 col float \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-row-rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-row-rd.shader_test"
+
+		emit_vs_rd_test $matrix_dim $array_dim $mode 1 1   float \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-row-rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-row-rd.shader_test"
+
+		emit_vs_rd_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-rd.shader_test"
+
+		emit_vs_rd_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-rd.shader_test"
+
+	    else
+		arr=""
+		idx_txt=""
+	    fi
+
+	    emit_fs_rd_test $matrix_dim $array_dim $mode index col float \
+		> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-rd.shader_test"
+
+	    emit_fs_rd_test $matrix_dim $array_dim $mode index 1   float \
+		> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-rd.shader_test"
+
+	    emit_fs_rd_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
+		> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-rd.shader_test"
+
+	    emit_fs_rd_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
+		> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}rd.shader_test
+		echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}rd.shader_test"
+
+	    emit_vs_rd_test $matrix_dim $array_dim $mode index col float \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-rd.shader_test"
+
+	    emit_vs_rd_test $matrix_dim $array_dim $mode index 1   float \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-rd.shader_test"
+
+	    emit_vs_rd_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-rd.shader_test"
+
+	    emit_vs_rd_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}rd.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}rd.shader_test"
+	done
+    done
+done
diff --git a/generated_tests/variable-index-write.sh b/generated_tests/variable-index-write.sh
new file mode 100755
index 00000000..52cd24e1
--- /dev/null
+++ b/generated_tests/variable-index-write.sh
@@ -0,0 +1,546 @@
+#!/bin/bash
+
+# Emit global variable declarations for either the vertex shader or the
+# fragment shader.
+function emit_globals
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col="[$5]"
+    value_type=$6
+
+    v=${version/./}
+    if [ $v -ge 120 ]; then
+	base_type="mat${matrix_dim}x${matrix_dim}"
+    else
+	base_type="mat${matrix_dim}"
+    fi
+
+    type=$base_type
+    dim=""
+    if [ $array_dim -ne 0 ]; then
+	if [ $v -ge 120 ]; then
+	    type="${type}[$array_dim]"
+	else
+	    dim="[${array_dim}]"
+	fi
+    fi
+
+    echo "uniform ${base_type} src_matrix;"
+    echo "uniform vec${matrix_dim} v;"
+    echo "uniform vec${matrix_dim} expect;"
+
+    if [ $array_dim -ne 0 ]; then
+	echo "uniform int index;"
+    fi
+
+    if [ "x$value_type" = "xfloat" ]; then
+	echo "uniform int row;"
+    fi
+
+    echo "uniform int col;"
+    echo "uniform ${value_type} value;"
+
+    if [ "x$mode" = "xvarying" ]; then
+	echo "varying ${type} dst_matrix${dim};"
+    fi
+    echo
+}
+
+
+function emit_set_matrix
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col="[$5]"
+    value_type=$6
+
+    v=${version/./}
+    if [ $v -ge 120 ]; then
+	base_type="mat${matrix_dim}x${matrix_dim}"
+    else
+	base_type="mat${matrix_dim}"
+    fi
+
+    type=$base_type
+    dim=""
+    if [ $array_dim -ne 0 ]; then
+	if [ $v -ge 120 ]; then
+	    type="${type}[$array_dim]"
+	else
+	    dim="[${array_dim}]"
+	fi
+    fi
+
+    if [ "x$mode" = "xtemp" ]; then
+	echo -n "    ${type} dst_matrix${dim}"
+	lhs=""
+    else
+	lhs="    dst_matrix"
+    fi
+
+    if [ $array_dim -ne 0 ]; then
+	if [ $v -ge 120 ]; then
+	    echo -n "${lhs} = ${type}("
+	    for i in $(seq $array_dim); do
+		if [ $i -ne 1 ]; then
+		    echo -n ", "
+		fi
+		echo -n "${base_type}(0.0)"
+	    done
+	    echo ");"
+	else
+	    if [ "x$mode" = "xtemp" ]; then
+		echo ";"
+	    fi
+
+	    for i in $(seq 0 $((array_dim - 1))); do
+		echo "    dst_matrix[$i] = ${base_type}(0.0);"
+	    done
+	fi
+    elif [ "x$mode" = "xtemp" ]; then
+	echo ";"
+    fi
+
+    echo
+}
+
+
+function emit_transform
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col="[$5]"
+    value_type=$6
+
+    if [ "x$value_type" = "xfloat" ]; then
+	row="[row]"
+    else
+	row=""
+    fi
+
+    cat <<EOF
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+EOF
+
+    if [ $array_dim -ne 0 ]; then
+	cat <<EOF
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+EOF
+	idx="[${index_value}]"
+    else
+	idx=""
+    fi
+
+    echo "     */"
+    echo "    dst_matrix${idx} = src_matrix;"
+    echo "    dst_matrix${idx}${col}${row} = value;"
+}
+
+
+function emit_fs
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col="[$5]"
+    value_type=$6
+
+    v=${version/./}
+    if [ $v -ge 120 ]; then
+	base_type="mat${matrix_dim}x${matrix_dim}"
+    else
+	base_type="mat${matrix_dim}"
+    fi
+
+    type=$base_type
+    dim=""
+    if [ $array_dim -ne 0 ]; then
+	if [ $v -ge 120 ]; then
+	    type="${type}[$array_dim]"
+	else
+	    dim="[${array_dim}]"
+	fi
+    fi
+
+    echo "[fragment shader]"
+    if [ $v -eq 100 ]; then
+        echo "precision highp float;"
+        echo "precision highp int;"
+    fi
+
+    emit_globals $*
+
+    echo "void main()"
+    echo "{"
+
+    # Assume for now that fragment shaders can only write to temporaries.
+    # There usually aren't enough MRT outputs for an array of matrices
+    # anyway.  Just like with vertex shader array inputs (attribute arrays),
+    # we'll probably need a non-shader_runner test to exercise that path.
+    if [ "x$mode" = "xtemp" ]; then
+	emit_set_matrix $*
+	emit_transform $*
+    fi
+
+    echo "    gl_FragColor = (distance(dst_matrix${idx} * v, expect) < 1e-6)"
+    echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
+    echo "}"
+    echo
+}
+
+
+function emit_test_vectors
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    index_value=$4
+    col=$5
+    value_type=$6
+    v=${version/./}
+
+    if [ "$v" -eq 100 ]; then
+        cat <<EOF
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+
+EOF
+    else
+        cat <<EOF
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+EOF
+    fi
+
+    # NOTE: shader_runner uses the matCxR names even for GLSL 1.10
+    type="mat${matrix_dim}x${matrix_dim}"
+
+    # Random input vector, a random matrix, and the result of multiplying that
+    # vector by that matrix.  Naturally, the matrices are listed in OpenGL
+    # column-major order
+    case "${matrix_dim}x${matrix_dim}" in
+	"2x2")
+	    vec="0.803161418975390 0.852987140792140"
+	    exp="0.708718134966688 1.452243795483797"
+	    mat="0.241498998195656 0.861223395812970
+                 0.603473877011433 0.891622340451180"
+	    ;;
+	"3x3")
+	    vec="0.681652305322399 0.210426138878113 0.185916924650237"
+	    exp="0.610649606928364 0.711906885823636 0.312244778977868"
+	    mat="0.493944462129466 0.722190133917966 0.239853948232558
+                 0.550143078409278 0.591962645398579 0.467616286531193
+                 0.850846377186973 0.511303112962423 0.270815003356504"
+	    ;;
+	"4x4")
+	    vec="0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839"
+	    exp="1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820"
+	    mat="0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+                 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+                 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+                 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782"
+	    ;;
+    esac
+
+    # Trim out the extra whitespace from the matrix data.  The extra space
+    # (above) makes it easier to read, but it makes it harder to generate
+    # sensible test scripts.
+    mat=$(echo $mat | tr '\n' ' ' | sed 's/[[:space:]]\+/ /g;s/[[:space:]]*$//g')
+
+    if [ $array_dim -eq 0 ]; then
+	sizes="1"
+    elif [ "x$index_value" = "xindex" ]; then
+	sizes=$(seq $array_dim)
+    else
+	sizes="2"
+    fi
+
+    if [ "x$value_type" = "xfloat" ]; then
+	rows=$(seq $matrix_dim)
+	bad="666.0"
+    else
+	rows=1
+	case $matrix_dim in
+	    2) bad="666.0 777.0";;
+	    3) bad="666.0 777.0 888.0";;
+	    4) bad="666.0 777.0 888.0 999.0";;
+	esac
+    fi
+
+    if [ "x$col" = "xcol" ]; then
+	columns=$(seq $matrix_dim)
+    else
+	columns="2"
+    fi
+
+    for i in $sizes; do
+	if [ $array_dim -ne 0 -a "x$index_value" = "xindex" ]; then
+	    echo "uniform int index $((i-1))"
+	fi
+
+	x_base=$(((i - 1) * (15 * matrix_dim + 10)))
+	for c in $columns; do
+	    if [ "x$col" = "xcol" ]; then
+		echo "uniform int col $((c-1))"
+	    fi
+
+            for r in $rows; do
+		if [ "x$value_type" = "xfloat" ]; then
+		    echo "uniform int row $((r-1))"
+		fi
+
+		d=$((matrix_dim * (c-1) + (r-1) + 1))
+		if [ "x$value_type" = "xfloat" ]; then
+		    v=$(echo $mat | cut -d' ' -f$d)
+		else
+		    v=$(echo $mat | cut -d' ' -f$d-$((d+matrix_dim-1)))
+		fi
+
+		echo "uniform vec${matrix_dim} v ${vec}"
+		echo "uniform vec${matrix_dim} expect ${exp}"
+		echo "uniform ${type} src_matrix ${mat/$v/$bad}"
+		echo "uniform ${value_type} value $v"
+
+		x=$((x_base + 15 * c - 10))
+		y=$((15 * r - 10))
+		echo "draw rect $x $y 10 10"
+
+		x=$(($x + 5))
+		y=$(($y + 5))
+		echo "probe rgb $x $y 0.0 1.0 0.0"
+		echo
+	    done
+	done
+    done
+}
+
+
+function emit_fs_wr_test
+{
+    v=${version/./}
+
+    echo "# Test generated by:"
+    echo "# ${cmd}"
+    echo
+    echo "[require]"
+    if [ "$v" -eq 100 ]; then
+        echo "GLSL ES >= ${version}"
+        echo "GL ES >= 2.0"
+    else
+        echo "GLSL >= ${version}"
+    fi
+    echo
+
+    echo "[vertex shader]"
+    if [ "$v" -eq 100 ]; then
+        echo "attribute vec4 vertex;"
+        echo "mat4 projection = mat4("
+        echo "    2.0/250.0, 0.0, 0.0, -1.0,"
+        echo "    0.0, 2.0/250.0, 0.0, -1.0,"
+        echo "    0.0, 0.0, -1.0, 0.0,"
+        echo "    0.0, 0.0, 0.0, 1.0);"
+        echo
+        echo "void main()"
+        echo "{"
+        echo "    gl_Position = vertex;"
+        echo "    gl_Position *= projection;"
+        echo "}"
+    else
+        echo "void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }"
+    fi
+    echo
+
+    emit_fs $*
+    emit_test_vectors $*
+}
+
+
+function emit_vs_wr_test
+{
+    matrix_dim=$1
+    array_dim=$2
+    mode=$3
+    v=${version/./}
+
+    echo "# Test generated by:"
+    echo "# ${cmd}"
+    echo
+    echo "[require]"
+    if [ "$v" -eq 100 ]; then
+        echo "GLSL ES >= ${version}"
+        echo "GL ES >= 2.0"
+    else
+        echo "GLSL >= ${version}"
+    fi
+    echo
+
+    echo "[vertex shader]"
+    if [ "$v" -eq 100 ]; then
+        echo "attribute vec4 vertex;"
+        echo "mat4 projection = mat4("
+        echo "    2.0/250.0, 0.0, 0.0, -1.0,"
+        echo "    0.0, 2.0/250.0, 0.0, -1.0,"
+        echo "    0.0, 0.0, -1.0, 0.0,"
+        echo "    0.0, 0.0, 0.0, 1.0);"
+    fi
+    emit_globals $*
+
+    echo "void main()"
+    echo "{"
+    if [ "$v" -eq 100 ]; then
+        echo "    gl_Position = vertex;"
+        echo "    gl_Position *= projection;"
+    else
+        echo "    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
+    fi
+    echo
+
+    emit_set_matrix $*
+    emit_transform $*
+
+    if [ "x$mode" != "xvarying" ] ; then
+	echo "    gl_FrontColor = (distance(dst_matrix${idx} * v, expect) < 1e-6)"
+	echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
+    fi
+
+    echo "}"
+    echo
+
+    if [ "x$mode" != "xvarying" ];then
+	echo "[fragment shader]"
+	echo "void main() { gl_FragColor = gl_Color; }"
+	echo
+    else
+	emit_fs $*
+    fi
+
+    emit_test_vectors $*
+}
+
+
+cmd="$0 $*"
+
+if [ "x$1" = "x" ]; then
+    version="1.10"
+else
+    case "$1" in
+	1.[012]0) version="$1";;
+	*)
+	    echo "Bogus GLSL version \"$1\" specified."
+	    exit 1
+	    ;;
+    esac
+fi
+
+v=${version/./}
+if [ $v -eq 100 ]; then
+	es="-es"
+fi
+
+filepath="spec/glsl"${es}-${version}"/execution/varible-index-write"
+mkdir -p ${filepath}
+
+for mode in temp varying; do
+    # More than 3 is unlikely to work for the varying tests due to using too
+    # many varying vectors.  mat4[3] uses 12 varying vectors by itself.
+    for array_dim in 0 3; do
+	if [ $array_dim -ne 0 ]; then
+	    arr="array-"
+	    idx_txt="index-"
+	else
+	    arr=""
+	    idx_txt=""
+	fi
+
+	for matrix_dim in 2 3 4; do
+	    # Fragment shaders cannot write varyings
+	    if [ "x$mode" != "xvarying" ]; then
+			emit_fs_wr_test $matrix_dim $array_dim $mode index col float \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-wr.shader_test
+			echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-wr.shader_test"
+
+			emit_fs_wr_test $matrix_dim $array_dim $mode index 1   float \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-wr.shader_test
+			echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-wr.shader_test"
+
+			emit_fs_wr_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-wr.shader_test
+			echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-wr.shader_test"
+
+			emit_fs_wr_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
+		    > ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}wr.shader_test
+			echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}wr.shader_test"
+
+			if [ $array_dim -ne 0 ]; then
+				emit_fs_wr_test $matrix_dim $array_dim $mode 1 col float \
+				> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-row-wr.shader_test
+				echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-row-wr.shader_test"
+
+				emit_fs_wr_test $matrix_dim $array_dim $mode 1 1   float \
+				> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-row-wr.shader_test
+				echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-row-wr.shader_test"
+
+				emit_fs_wr_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
+				> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-wr.shader_test
+				echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-col-wr.shader_test"
+
+				emit_fs_wr_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
+				> ${filepath}/fs-${mode}-${arr}mat${matrix_dim}-wr.shader_test
+				echo "${filepath}/fs-${mode}-${arr}mat${matrix_dim}-wr.shader_test"
+			fi
+	    fi
+
+	    emit_vs_wr_test $matrix_dim $array_dim $mode index col float \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-wr.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-wr.shader_test"
+
+	    emit_vs_wr_test $matrix_dim $array_dim $mode index 1   float \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-wr.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-wr.shader_test"
+
+	    emit_vs_wr_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-wr.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-wr.shader_test"
+
+	    emit_vs_wr_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
+		> ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}wr.shader_test
+		echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}wr.shader_test"
+
+	    if [ $array_dim -ne 0 ]; then
+			emit_vs_wr_test $matrix_dim $array_dim $mode 1 col float \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-row-wr.shader_test
+			echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-row-wr.shader_test"
+
+			emit_vs_wr_test $matrix_dim $array_dim $mode 1 1   float \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-row-wr.shader_test
+			echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-row-wr.shader_test"
+
+			emit_vs_wr_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-wr.shader_test
+			echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-col-wr.shader_test"
+
+			emit_vs_wr_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
+		    > ${filepath}/vs-${mode}-${arr}mat${matrix_dim}-wr.shader_test
+			echo "${filepath}/vs-${mode}-${arr}mat${matrix_dim}-wr.shader_test"
+	    fi
+	done
+    done
+done
diff --git a/tests/all_es2.tests b/tests/all_es2.tests
new file mode 100644
index 00000000..1d6e5352
--- /dev/null
+++ b/tests/all_es2.tests
@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+
+import itertools
+import os
+import os.path as path
+import platform
+
+from framework.core import *
+from framework.exectest import *
+from framework.glsl_parser_test import GLSLESParserTest, add_glsl_es_parser_test
+from framework.shader_test import add_shader_test, add_shader_test_dir
+# ShaderTest, ShaderES2Test
+
+
+# Blacklisted tests are removed from the test profile.
+blacklist = [ ]
+
+# Path to tests dir, correct even when not running from the top directory.
+testsDir = path.dirname(__file__)
+
+# Find the generated_tests directory, by looking either in
+# $PIGLIT_BUILD_DIR (if that environment variable exists) or in the
+# parent directory of the directory containing this file.
+generatedTestDir = os.path.join(
+    os.environ.get(
+        'PIGLIT_BUILD_DIR',
+        os.path.join(testsDir, '..')),
+    'generated_tests')
+
+# Quick wrapper for PlainExecTest for our usual concurrent args.
+def plain_test(name):
+    return PlainExecTest([name, '-auto'])
+
+def add_single_param_test_set(group, name, *params):
+    for param in params:
+        group[name + '-' + param] = PlainExecTest([name, param, '-auto'])
+
+def add_plain_test(group, name):
+    group[name] = PlainExecTest([name, '-auto'])
+
+def concurrent_test(args):
+    test = PlainExecTest(args.split() + ['-auto', '-fbo'])
+    test.runConcurrent = True
+    return test
+
+def add_concurrent_test(group, args):
+    group[args] = concurrent_test(args)
+
+# Generate all possible subsets of the given set, including the empty set.
+def power_set(s):
+        if len(s) == 0:
+                return [[]]
+        result = []
+        for p in power_set(s[:-1]):
+                result.append(p)
+                result.append(p + [s[-1]])
+        return result
+
+profile = TestProfile()
+
+gles20 = Group()
+spec = Group()
+spec['!OpenGL ES 2.0'] = gles20
+gles20['gles2_sanity_test'] = PlainExecTest(['sanity-test_gles2', '-auto'])
+gles20['gles2_glReadPixels'] = PlainExecTest(['glReadPixels_gles2', '-auto'])
+gles20['gles2_clear_varray-2.0'] = PlainExecTest(['clear-varray-2.0_gles2', '-auto'])
+gles20['gles2_minmax'] = PlainExecTest(['minmax_gles2', '-auto'])
+gles20['gles2-invalid-es3-queries'] = PlainExecTest(['invalid-es3-queries_gles2', '-auto'])
+
+glslparser = Group()
+spec['!glsl es 1.0 parser'] = glslparser
+# Add all shader source files in the directories below for gles20
+for filename in os.listdir(testsDir + '/glslparsertest/shaders'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'glslparsertest/shaders', filename), filename)
+del glslparser['CorrectPreprocess11.frag']
+for filename in os.listdir(testsDir + '/glslparsertest/glsl2'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'glslparsertest/glsl2', filename), 'glsl2/' + filename)
+
+for filename in os.listdir(testsDir + '/spec/glsl-es-1.00/compiler/arithmetic-operators'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'spec/glsl-es-1.00/compiler/arithmetic-operators', filename), filename)
+for filename in os.listdir(testsDir + '/spec/glsl-es-1.00/compiler/assignment-operators'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'spec/glsl-es-1.00/compiler/assignment-operators', filename), filename)
+for filename in os.listdir(testsDir + '/spec/glsl-es-1.00/compiler/built-in-functions'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'spec/glsl-es-1.00/compiler/built-in-functions', filename), filename)
+for filename in os.listdir(testsDir + '/spec/glsl-es-1.00/compiler/clipping'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'spec/glsl-es-1.00/compiler/clipping', filename), filename)
+for filename in os.listdir(testsDir + '/spec/glsl-es-1.00/compiler/qualifiers'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'spec/glsl-es-1.00/compiler/qualifiers', filename), filename)
+for filename in os.listdir(testsDir + '/spec/glsl-es-1.00/compiler/storage-qualifiers'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'spec/glsl-es-1.00/compiler/storage-qualifiers', filename), filename)
+for filename in os.listdir(testsDir + '/spec/glsl-es-1.00/compiler/structure-and-array-operations'):
+	ext = filename.rsplit('.')[-1]
+	if ext in ['vert', 'geo', 'frag']:
+		add_glsl_es_parser_test(glslparser, path.join(testsDir, 'spec/glsl-es-1.00/compiler/structure-and-array-operations', filename), filename)
+
+shader = Group()
+spec['!glsl es 1.0 shader'] = shader
+add_shader_test_dir(shader, os.path.join(testsDir, 'spec', 'glsl-es-1.00','execution'), recursive=True)
+add_shader_test_dir(shader, os.path.join(generatedTestDir, 'spec', 'glsl-es-1.00','execution'), recursive=True)
+
+#glsl-es-1.00/compiler/arithmetic-operators/
+#add_shader_es2_test_dir(shader, os.path.join(testsDir, 'shaders'), recursive=True)
+#add_shader_es2_test_dir(shader, os.path.join(testsDir, 'spec', 'glsl-1.10', 'execution'), recursive=True)
+#add_shader_es2_test_dir(shader, os.path.join(testsDir, 'spec', 'glsl-1.20', 'execution'), recursive=True)
+#import_glsl_parser_tests(profile.tests, generatedTestDir, ['gles20'])
+
+profile.tests['spec'] = spec
diff --git a/tests/glslparsertest/glsl2/16384-consecutive-chars.frag b/tests/glslparsertest/glsl2/16384-consecutive-chars.frag
index 868267d4..d006fa76 100644
--- a/tests/glslparsertest/glsl2/16384-consecutive-chars.frag
+++ b/tests/glslparsertest/glsl2/16384-consecutive-chars.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 /* 16384 consecutive characters without a newline. */
diff --git a/tests/glslparsertest/glsl2/16385-consecutive-chars.frag b/tests/glslparsertest/glsl2/16385-consecutive-chars.frag
index 32fdaef7..91dbdedf 100644
--- a/tests/glslparsertest/glsl2/16385-consecutive-chars.frag
+++ b/tests/glslparsertest/glsl2/16385-consecutive-chars.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 /* 16385 consecutive characters without a newline. */
diff --git a/tests/glslparsertest/glsl2/17000-consecutive-chars-identifier.frag b/tests/glslparsertest/glsl2/17000-consecutive-chars-identifier.frag
index c1b0c493..1b2f0f9b 100644
--- a/tests/glslparsertest/glsl2/17000-consecutive-chars-identifier.frag
+++ b/tests/glslparsertest/glsl2/17000-consecutive-chars-identifier.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 void main()
 {
diff --git a/tests/glslparsertest/glsl2/array-04.vert b/tests/glslparsertest/glsl2/array-04.vert
index d46bc80c..eddc2646 100644
--- a/tests/glslparsertest/glsl2/array-04.vert
+++ b/tests/glslparsertest/glsl2/array-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-05.vert b/tests/glslparsertest/glsl2/array-05.vert
index 3b920728..256a5caf 100644
--- a/tests/glslparsertest/glsl2/array-05.vert
+++ b/tests/glslparsertest/glsl2/array-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-06.vert b/tests/glslparsertest/glsl2/array-06.vert
index d37e2de3..2f2d9247 100644
--- a/tests/glslparsertest/glsl2/array-06.vert
+++ b/tests/glslparsertest/glsl2/array-06.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-07.vert b/tests/glslparsertest/glsl2/array-07.vert
index 589e687e..dffe90ff 100644
--- a/tests/glslparsertest/glsl2/array-07.vert
+++ b/tests/glslparsertest/glsl2/array-07.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-08.vert b/tests/glslparsertest/glsl2/array-08.vert
index cf28b4fe..4369cacf 100644
--- a/tests/glslparsertest/glsl2/array-08.vert
+++ b/tests/glslparsertest/glsl2/array-08.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-10.vert b/tests/glslparsertest/glsl2/array-10.vert
index 7c71daa0..c2b54628 100644
--- a/tests/glslparsertest/glsl2/array-10.vert
+++ b/tests/glslparsertest/glsl2/array-10.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-14.vert b/tests/glslparsertest/glsl2/array-14.vert
index b3eb93b5..1d6ac0a8 100644
--- a/tests/glslparsertest/glsl2/array-14.vert
+++ b/tests/glslparsertest/glsl2/array-14.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-15.vert b/tests/glslparsertest/glsl2/array-15.vert
index c00ca0f6..823a5304 100644
--- a/tests/glslparsertest/glsl2/array-15.vert
+++ b/tests/glslparsertest/glsl2/array-15.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-19.vert b/tests/glslparsertest/glsl2/array-19.vert
index a5a037d4..59a02017 100644
--- a/tests/glslparsertest/glsl2/array-19.vert
+++ b/tests/glslparsertest/glsl2/array-19.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-20.vert b/tests/glslparsertest/glsl2/array-20.vert
index b13b659e..685e9fc1 100644
--- a/tests/glslparsertest/glsl2/array-20.vert
+++ b/tests/glslparsertest/glsl2/array-20.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-21.vert b/tests/glslparsertest/glsl2/array-21.vert
index 0da58877..d615b61c 100644
--- a/tests/glslparsertest/glsl2/array-21.vert
+++ b/tests/glslparsertest/glsl2/array-21.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/array-22.vert b/tests/glslparsertest/glsl2/array-22.vert
index 483454d5..aea471ba 100644
--- a/tests/glslparsertest/glsl2/array-22.vert
+++ b/tests/glslparsertest/glsl2/array-22.vert
@@ -7,6 +7,7 @@
  * [config]
  * expect_result: fail
  * glsl_version: 1.10
+// glsles_version: 1.00
  * [end config]
  */
 uniform int i;
diff --git a/tests/glslparsertest/glsl2/array-23.vert b/tests/glslparsertest/glsl2/array-23.vert
index df09137f..d9c96f18 100644
--- a/tests/glslparsertest/glsl2/array-23.vert
+++ b/tests/glslparsertest/glsl2/array-23.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 void main()
diff --git a/tests/glslparsertest/glsl2/array-24.vert b/tests/glslparsertest/glsl2/array-24.vert
index 90cd663e..e6a8e69d 100644
--- a/tests/glslparsertest/glsl2/array-24.vert
+++ b/tests/glslparsertest/glsl2/array-24.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 void main()
diff --git a/tests/glslparsertest/glsl2/array-25.vert b/tests/glslparsertest/glsl2/array-25.vert
index becdf3d1..5518a343 100644
--- a/tests/glslparsertest/glsl2/array-25.vert
+++ b/tests/glslparsertest/glsl2/array-25.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 void main()
diff --git a/tests/glslparsertest/glsl2/array-compare-03.vert b/tests/glslparsertest/glsl2/array-compare-03.vert
index 45a376da..ebdf50e1 100644
--- a/tests/glslparsertest/glsl2/array-compare-03.vert
+++ b/tests/glslparsertest/glsl2/array-compare-03.vert
@@ -6,6 +6,7 @@
  * [config]
  * expect_result: fail
  * glsl_version: 1.10
+// glsles_version: 1.00
  * [end config]
  */
 varying vec4 color;
diff --git a/tests/glslparsertest/glsl2/array-length-110.frag b/tests/glslparsertest/glsl2/array-length-110.frag
index 9302e00c..3aa27072 100644
--- a/tests/glslparsertest/glsl2/array-length-110.frag
+++ b/tests/glslparsertest/glsl2/array-length-110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/assignment-type-mismatch.vert b/tests/glslparsertest/glsl2/assignment-type-mismatch.vert
index 0169d497..6c2f7b61 100644
--- a/tests/glslparsertest/glsl2/assignment-type-mismatch.vert
+++ b/tests/glslparsertest/glsl2/assignment-type-mismatch.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-01.vert b/tests/glslparsertest/glsl2/attribute-01.vert
index 7a787d93..75f470cd 100644
--- a/tests/glslparsertest/glsl2/attribute-01.vert
+++ b/tests/glslparsertest/glsl2/attribute-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-02.vert b/tests/glslparsertest/glsl2/attribute-02.vert
index 36a86c01..d01b1fb7 100644
--- a/tests/glslparsertest/glsl2/attribute-02.vert
+++ b/tests/glslparsertest/glsl2/attribute-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-03.vert b/tests/glslparsertest/glsl2/attribute-03.vert
index b9a2ca0f..95ddd685 100644
--- a/tests/glslparsertest/glsl2/attribute-03.vert
+++ b/tests/glslparsertest/glsl2/attribute-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-04.vert b/tests/glslparsertest/glsl2/attribute-04.vert
index 14902c9b..1cba7258 100644
--- a/tests/glslparsertest/glsl2/attribute-04.vert
+++ b/tests/glslparsertest/glsl2/attribute-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-05.vert b/tests/glslparsertest/glsl2/attribute-05.vert
index 75a06da4..860331f4 100644
--- a/tests/glslparsertest/glsl2/attribute-05.vert
+++ b/tests/glslparsertest/glsl2/attribute-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-06.vert b/tests/glslparsertest/glsl2/attribute-06.vert
index 0aadd31d..adb2526e 100644
--- a/tests/glslparsertest/glsl2/attribute-06.vert
+++ b/tests/glslparsertest/glsl2/attribute-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-07.vert b/tests/glslparsertest/glsl2/attribute-07.vert
index 07cf7458..9363eba3 100644
--- a/tests/glslparsertest/glsl2/attribute-07.vert
+++ b/tests/glslparsertest/glsl2/attribute-07.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-08.vert b/tests/glslparsertest/glsl2/attribute-08.vert
index 81c6050b..5f8f6e9c 100644
--- a/tests/glslparsertest/glsl2/attribute-08.vert
+++ b/tests/glslparsertest/glsl2/attribute-08.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-09.vert b/tests/glslparsertest/glsl2/attribute-09.vert
index 73deac0a..4e365dc6 100644
--- a/tests/glslparsertest/glsl2/attribute-09.vert
+++ b/tests/glslparsertest/glsl2/attribute-09.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/attribute-10.vert b/tests/glslparsertest/glsl2/attribute-10.vert
index 487aeff3..e26711a7 100644
--- a/tests/glslparsertest/glsl2/attribute-10.vert
+++ b/tests/glslparsertest/glsl2/attribute-10.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/bit-not-01.frag b/tests/glslparsertest/glsl2/bit-not-01.frag
index d64228e0..1a190027 100644
--- a/tests/glslparsertest/glsl2/bit-not-01.frag
+++ b/tests/glslparsertest/glsl2/bit-not-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/bit-not-02.frag b/tests/glslparsertest/glsl2/bit-not-02.frag
index 523b5f74..4d27c3a0 100644
--- a/tests/glslparsertest/glsl2/bit-not-02.frag
+++ b/tests/glslparsertest/glsl2/bit-not-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/bit-not-09.frag b/tests/glslparsertest/glsl2/bit-not-09.frag
index 4f3a6489..631c69ee 100644
--- a/tests/glslparsertest/glsl2/bit-not-09.frag
+++ b/tests/glslparsertest/glsl2/bit-not-09.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 // [end config]
 
 /* FAIL - bitwise operations aren't supported in 1.20. */
diff --git a/tests/glslparsertest/glsl2/builtin-texturematrix.frag b/tests/glslparsertest/glsl2/builtin-texturematrix.frag
index 1edb50f8..23115f7b 100644
--- a/tests/glslparsertest/glsl2/builtin-texturematrix.frag
+++ b/tests/glslparsertest/glsl2/builtin-texturematrix.frag
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/comment-continuation-preprocessor.frag b/tests/glslparsertest/glsl2/comment-continuation-preprocessor.frag
index 4f84b0a2..e03495f4 100644
--- a/tests/glslparsertest/glsl2/comment-continuation-preprocessor.frag
+++ b/tests/glslparsertest/glsl2/comment-continuation-preprocessor.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // [end config]
 //
diff --git a/tests/glslparsertest/glsl2/condition-01.vert b/tests/glslparsertest/glsl2/condition-01.vert
index b95b8a0b..113c4f02 100644
--- a/tests/glslparsertest/glsl2/condition-01.vert
+++ b/tests/glslparsertest/glsl2/condition-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/condition-02.vert b/tests/glslparsertest/glsl2/condition-02.vert
index 87332229..ae01fe89 100644
--- a/tests/glslparsertest/glsl2/condition-02.vert
+++ b/tests/glslparsertest/glsl2/condition-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/condition-03.vert b/tests/glslparsertest/glsl2/condition-03.vert
index c3629666..04f1a1df 100644
--- a/tests/glslparsertest/glsl2/condition-03.vert
+++ b/tests/glslparsertest/glsl2/condition-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/condition-04.vert b/tests/glslparsertest/glsl2/condition-04.vert
index 94bfdf3d..373260af 100644
--- a/tests/glslparsertest/glsl2/condition-04.vert
+++ b/tests/glslparsertest/glsl2/condition-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/condition-05.vert b/tests/glslparsertest/glsl2/condition-05.vert
index 1b429373..86bbef99 100644
--- a/tests/glslparsertest/glsl2/condition-05.vert
+++ b/tests/glslparsertest/glsl2/condition-05.vert
@@ -8,6 +8,7 @@
 // [end config]
 
 #version 120
+
 /* PASS */
 
 uniform bool a;
diff --git a/tests/glslparsertest/glsl2/condition-06.vert b/tests/glslparsertest/glsl2/condition-06.vert
index e9dae0a3..56ee2210 100644
--- a/tests/glslparsertest/glsl2/condition-06.vert
+++ b/tests/glslparsertest/glsl2/condition-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/condition-08.vert b/tests/glslparsertest/glsl2/condition-08.vert
index 0b819aa2..2ebfc26a 100644
--- a/tests/glslparsertest/glsl2/condition-08.vert
+++ b/tests/glslparsertest/glsl2/condition-08.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 uniform bool b;
diff --git a/tests/glslparsertest/glsl2/const-builtin-110.frag b/tests/glslparsertest/glsl2/const-builtin-110.frag
index 53e21cd9..b0a58eb1 100644
--- a/tests/glslparsertest/glsl2/const-builtin-110.frag
+++ b/tests/glslparsertest/glsl2/const-builtin-110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-builtin-noise1.frag b/tests/glslparsertest/glsl2/const-builtin-noise1.frag
index 1fc9281f..5f8149fa 100644
--- a/tests/glslparsertest/glsl2/const-builtin-noise1.frag
+++ b/tests/glslparsertest/glsl2/const-builtin-noise1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-builtin-noise2.frag b/tests/glslparsertest/glsl2/const-builtin-noise2.frag
index 56442f2b..73e03489 100644
--- a/tests/glslparsertest/glsl2/const-builtin-noise2.frag
+++ b/tests/glslparsertest/glsl2/const-builtin-noise2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-builtin-noise3.frag b/tests/glslparsertest/glsl2/const-builtin-noise3.frag
index 5a45e0a5..cf5ec3de 100644
--- a/tests/glslparsertest/glsl2/const-builtin-noise3.frag
+++ b/tests/glslparsertest/glsl2/const-builtin-noise3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-builtin-noise4.frag b/tests/glslparsertest/glsl2/const-builtin-noise4.frag
index 960547e5..c65d44b3 100644
--- a/tests/glslparsertest/glsl2/const-builtin-noise4.frag
+++ b/tests/glslparsertest/glsl2/const-builtin-noise4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-implicit-conversion.frag b/tests/glslparsertest/glsl2/const-implicit-conversion.frag
index 04118119..65358743 100644
--- a/tests/glslparsertest/glsl2/const-implicit-conversion.frag
+++ b/tests/glslparsertest/glsl2/const-implicit-conversion.frag
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-mat-scalar-01.frag b/tests/glslparsertest/glsl2/const-mat-scalar-01.frag
index c037cdb1..ff802b57 100644
--- a/tests/glslparsertest/glsl2/const-mat-scalar-01.frag
+++ b/tests/glslparsertest/glsl2/const-mat-scalar-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-mat-scalar-02.frag b/tests/glslparsertest/glsl2/const-mat-scalar-02.frag
index 22d7cfef..92a2f5b0 100644
--- a/tests/glslparsertest/glsl2/const-mat-scalar-02.frag
+++ b/tests/glslparsertest/glsl2/const-mat-scalar-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-mat-scalar-03.frag b/tests/glslparsertest/glsl2/const-mat-scalar-03.frag
index f8668ae4..59706f18 100644
--- a/tests/glslparsertest/glsl2/const-mat-scalar-03.frag
+++ b/tests/glslparsertest/glsl2/const-mat-scalar-03.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-mat-scalar-04.frag b/tests/glslparsertest/glsl2/const-mat-scalar-04.frag
index 7bcdeb8e..aa87c728 100644
--- a/tests/glslparsertest/glsl2/const-mat-scalar-04.frag
+++ b/tests/glslparsertest/glsl2/const-mat-scalar-04.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-matrix-multiply-01.frag b/tests/glslparsertest/glsl2/const-matrix-multiply-01.frag
index 4eade7cc..addd38e4 100644
--- a/tests/glslparsertest/glsl2/const-matrix-multiply-01.frag
+++ b/tests/glslparsertest/glsl2/const-matrix-multiply-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-matrix-multiply-02.frag b/tests/glslparsertest/glsl2/const-matrix-multiply-02.frag
index 71bc1e09..9889b944 100644
--- a/tests/glslparsertest/glsl2/const-matrix-multiply-02.frag
+++ b/tests/glslparsertest/glsl2/const-matrix-multiply-02.frag
@@ -1,13 +1,19 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
 // # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
 // [end config]
 
+#ifndef GL_ES
 #version 120
+#else
+#version 100
+#endif
+
 void main()
 {
    const mat3x2 c1 = mat3x2(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
diff --git a/tests/glslparsertest/glsl2/const-userfunction.frag b/tests/glslparsertest/glsl2/const-userfunction.frag
index 6c3bcc2b..8db60195 100644
--- a/tests/glslparsertest/glsl2/const-userfunction.frag
+++ b/tests/glslparsertest/glsl2/const-userfunction.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-vec-mat.frag b/tests/glslparsertest/glsl2/const-vec-mat.frag
index d7bed88a..e5d1c7fb 100644
--- a/tests/glslparsertest/glsl2/const-vec-mat.frag
+++ b/tests/glslparsertest/glsl2/const-vec-mat.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-vec-scalar-01.frag b/tests/glslparsertest/glsl2/const-vec-scalar-01.frag
index f4957a29..c9920b39 100644
--- a/tests/glslparsertest/glsl2/const-vec-scalar-01.frag
+++ b/tests/glslparsertest/glsl2/const-vec-scalar-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-vec-scalar-02.frag b/tests/glslparsertest/glsl2/const-vec-scalar-02.frag
index a5f665da..760b79b9 100644
--- a/tests/glslparsertest/glsl2/const-vec-scalar-02.frag
+++ b/tests/glslparsertest/glsl2/const-vec-scalar-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-vec-scalar-03.frag b/tests/glslparsertest/glsl2/const-vec-scalar-03.frag
index 5b158822..9f7d00fc 100644
--- a/tests/glslparsertest/glsl2/const-vec-scalar-03.frag
+++ b/tests/glslparsertest/glsl2/const-vec-scalar-03.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-vec-scalar-04.frag b/tests/glslparsertest/glsl2/const-vec-scalar-04.frag
index 148e14ba..0f085e89 100644
--- a/tests/glslparsertest/glsl2/const-vec-scalar-04.frag
+++ b/tests/glslparsertest/glsl2/const-vec-scalar-04.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/const-vec-scalar-05.frag b/tests/glslparsertest/glsl2/const-vec-scalar-05.frag
index c92e76ee..ac7f3cd6 100644
--- a/tests/glslparsertest/glsl2/const-vec-scalar-05.frag
+++ b/tests/glslparsertest/glsl2/const-vec-scalar-05.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-01.vert b/tests/glslparsertest/glsl2/constructor-01.vert
index 1f3db50d..c340361f 100644
--- a/tests/glslparsertest/glsl2/constructor-01.vert
+++ b/tests/glslparsertest/glsl2/constructor-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-02.vert b/tests/glslparsertest/glsl2/constructor-02.vert
index 9532ff18..df63b3c3 100644
--- a/tests/glslparsertest/glsl2/constructor-02.vert
+++ b/tests/glslparsertest/glsl2/constructor-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-03.vert b/tests/glslparsertest/glsl2/constructor-03.vert
index 6ce16b44..14854311 100644
--- a/tests/glslparsertest/glsl2/constructor-03.vert
+++ b/tests/glslparsertest/glsl2/constructor-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-04.vert b/tests/glslparsertest/glsl2/constructor-04.vert
index 3d3daa47..179904eb 100644
--- a/tests/glslparsertest/glsl2/constructor-04.vert
+++ b/tests/glslparsertest/glsl2/constructor-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-05.vert b/tests/glslparsertest/glsl2/constructor-05.vert
index 3e7bcd00..c008d6d0 100644
--- a/tests/glslparsertest/glsl2/constructor-05.vert
+++ b/tests/glslparsertest/glsl2/constructor-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-07.vert b/tests/glslparsertest/glsl2/constructor-07.vert
index 68f37499..ef6b5dbc 100644
--- a/tests/glslparsertest/glsl2/constructor-07.vert
+++ b/tests/glslparsertest/glsl2/constructor-07.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: false
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-08.vert b/tests/glslparsertest/glsl2/constructor-08.vert
index 505c8202..1cfa0395 100644
--- a/tests/glslparsertest/glsl2/constructor-08.vert
+++ b/tests/glslparsertest/glsl2/constructor-08.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-09.vert b/tests/glslparsertest/glsl2/constructor-09.vert
index ac2563bc..e97b47d3 100644
--- a/tests/glslparsertest/glsl2/constructor-09.vert
+++ b/tests/glslparsertest/glsl2/constructor-09.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-10.vert b/tests/glslparsertest/glsl2/constructor-10.vert
index c94f0325..72439de4 100644
--- a/tests/glslparsertest/glsl2/constructor-10.vert
+++ b/tests/glslparsertest/glsl2/constructor-10.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-11.vert b/tests/glslparsertest/glsl2/constructor-11.vert
index dd32c5e3..a8b66d9d 100644
--- a/tests/glslparsertest/glsl2/constructor-11.vert
+++ b/tests/glslparsertest/glsl2/constructor-11.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-12.vert b/tests/glslparsertest/glsl2/constructor-12.vert
index 5cf5e9ce..25a3d036 100644
--- a/tests/glslparsertest/glsl2/constructor-12.vert
+++ b/tests/glslparsertest/glsl2/constructor-12.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-13.vert b/tests/glslparsertest/glsl2/constructor-13.vert
index c97a1ee9..7d17e788 100644
--- a/tests/glslparsertest/glsl2/constructor-13.vert
+++ b/tests/glslparsertest/glsl2/constructor-13.vert
@@ -1,13 +1,17 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
 // # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
 // [end config]
 
+#ifndef GL_ES
 #version 120
+#endif
+
 void main()
 {
    const mat3x2 m = mat3x2(ivec3(1,2,3),ivec3(4,5,6));
diff --git a/tests/glslparsertest/glsl2/constructor-14.vert b/tests/glslparsertest/glsl2/constructor-14.vert
index 24388dc6..f2bf3543 100644
--- a/tests/glslparsertest/glsl2/constructor-14.vert
+++ b/tests/glslparsertest/glsl2/constructor-14.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-15.vert b/tests/glslparsertest/glsl2/constructor-15.vert
index 1d59364b..612903bc 100644
--- a/tests/glslparsertest/glsl2/constructor-15.vert
+++ b/tests/glslparsertest/glsl2/constructor-15.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-16.vert b/tests/glslparsertest/glsl2/constructor-16.vert
index 72ea4ae9..846ebad2 100644
--- a/tests/glslparsertest/glsl2/constructor-16.vert
+++ b/tests/glslparsertest/glsl2/constructor-16.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
@@ -8,7 +9,10 @@
 // [end config]
 
 /* PASS */
+#ifndef GL_ES
 #version 120
+#endif
+
 uniform vec2 u1;
 
 void main()
diff --git a/tests/glslparsertest/glsl2/constructor-17.vert b/tests/glslparsertest/glsl2/constructor-17.vert
index 6226a8a3..a4cc6aae 100644
--- a/tests/glslparsertest/glsl2/constructor-17.vert
+++ b/tests/glslparsertest/glsl2/constructor-17.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-18.vert b/tests/glslparsertest/glsl2/constructor-18.vert
index 7d92626a..1f58fff5 100644
--- a/tests/glslparsertest/glsl2/constructor-18.vert
+++ b/tests/glslparsertest/glsl2/constructor-18.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
@@ -8,7 +9,9 @@
 // [end config]
 
 /* PASS */
+#ifndef GL_ES
 #version 120
+#endif
 
 void main()
 {
diff --git a/tests/glslparsertest/glsl2/constructor-19.vert b/tests/glslparsertest/glsl2/constructor-19.vert
index 033edd35..d5390041 100644
--- a/tests/glslparsertest/glsl2/constructor-19.vert
+++ b/tests/glslparsertest/glsl2/constructor-19.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
@@ -8,7 +9,9 @@
 // [end config]
 
 /* PASS */
+#ifndef GL_ES
 #version 120
+#endif
 
 void main()
 {
diff --git a/tests/glslparsertest/glsl2/constructor-20.vert b/tests/glslparsertest/glsl2/constructor-20.vert
index 39092ce8..b2df8e52 100644
--- a/tests/glslparsertest/glsl2/constructor-20.vert
+++ b/tests/glslparsertest/glsl2/constructor-20.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
@@ -8,7 +9,9 @@
 // [end config]
 
 /* PASS */
+#ifndef GL_ES
 #version 120
+#endif
 
 void main()
 {
diff --git a/tests/glslparsertest/glsl2/constructor-21.vert b/tests/glslparsertest/glsl2/constructor-21.vert
index 1cc9002e..e18d3bec 100644
--- a/tests/glslparsertest/glsl2/constructor-21.vert
+++ b/tests/glslparsertest/glsl2/constructor-21.vert
@@ -1,13 +1,16 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
 // # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
 // [end config]
-
+#ifndef GL_ES
 #version 120
+#endif
+
 void main()
 {
    const mat2 m2 = mat2(2.00, 2.01, 2.10, 2.11);
diff --git a/tests/glslparsertest/glsl2/constructor-22.vert b/tests/glslparsertest/glsl2/constructor-22.vert
index 329a85ad..a9e10870 100644
--- a/tests/glslparsertest/glsl2/constructor-22.vert
+++ b/tests/glslparsertest/glsl2/constructor-22.vert
@@ -1,13 +1,17 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
 // # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
 // [end config]
 
+#ifndef GL_ES
 #version 120
+#endif
+
 void main()
 {
    const mat3 m3 = mat3(3.00, 3.01, 3.02, 3.10, 3.11, 3.12, 3.20, 3.21, 3.22);
diff --git a/tests/glslparsertest/glsl2/constructor-23.vert b/tests/glslparsertest/glsl2/constructor-23.vert
index fd2b9d49..e0168775 100644
--- a/tests/glslparsertest/glsl2/constructor-23.vert
+++ b/tests/glslparsertest/glsl2/constructor-23.vert
@@ -1,13 +1,16 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
 // # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
 // [end config]
-
+#ifndef GL_ES
 #version 120
+#endif
+
 uniform mat2 m2;
 varying mat4 m4;
 void main()
diff --git a/tests/glslparsertest/glsl2/constructor-24.vert b/tests/glslparsertest/glsl2/constructor-24.vert
index 8ae7d47a..3e408682 100644
--- a/tests/glslparsertest/glsl2/constructor-24.vert
+++ b/tests/glslparsertest/glsl2/constructor-24.vert
@@ -1,13 +1,19 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
 // # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
 // [end config]
 
+#ifndef GL_ES
 #version 120
+#else
+#version 100
+#endif
+
 uniform mat3 m3;
 varying mat2 m2;
 void main()
diff --git a/tests/glslparsertest/glsl2/constructor-25.vert b/tests/glslparsertest/glsl2/constructor-25.vert
index f272118e..5f235aef 100644
--- a/tests/glslparsertest/glsl2/constructor-25.vert
+++ b/tests/glslparsertest/glsl2/constructor-25.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/constructor-26.vert b/tests/glslparsertest/glsl2/constructor-26.vert
index fb3fad7e..bfb79dfb 100644
--- a/tests/glslparsertest/glsl2/constructor-26.vert
+++ b/tests/glslparsertest/glsl2/constructor-26.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
@@ -8,7 +9,12 @@
 // [end config]
 
 /* PASS */
+#ifndef GL_ES
 #version 120
+#else
+#version 100
+#endif
+
 struct s { float f; };
 
 void main()
diff --git a/tests/glslparsertest/glsl2/constructor-27.vert b/tests/glslparsertest/glsl2/constructor-27.vert
index b1c5ab48..532e3aef 100644
--- a/tests/glslparsertest/glsl2/constructor-27.vert
+++ b/tests/glslparsertest/glsl2/constructor-27.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/draw_buffers-07.vert b/tests/glslparsertest/glsl2/draw_buffers-07.vert
index 66d75cb5..b99e3db1 100644
--- a/tests/glslparsertest/glsl2/draw_buffers-07.vert
+++ b/tests/glslparsertest/glsl2/draw_buffers-07.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/draw_buffers-09.frag b/tests/glslparsertest/glsl2/draw_buffers-09.frag
index e0484195..a8608ff1 100644
--- a/tests/glslparsertest/glsl2/draw_buffers-09.frag
+++ b/tests/glslparsertest/glsl2/draw_buffers-09.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-01.vert b/tests/glslparsertest/glsl2/function-01.vert
index b68af742..a03e229f 100644
--- a/tests/glslparsertest/glsl2/function-01.vert
+++ b/tests/glslparsertest/glsl2/function-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-02.vert b/tests/glslparsertest/glsl2/function-02.vert
index a325aa1c..c89bb604 100644
--- a/tests/glslparsertest/glsl2/function-02.vert
+++ b/tests/glslparsertest/glsl2/function-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-03.vert b/tests/glslparsertest/glsl2/function-03.vert
index a01aa69e..4568ee14 100644
--- a/tests/glslparsertest/glsl2/function-03.vert
+++ b/tests/glslparsertest/glsl2/function-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-04.vert b/tests/glslparsertest/glsl2/function-04.vert
index cdac830a..1d0ebc18 100644
--- a/tests/glslparsertest/glsl2/function-04.vert
+++ b/tests/glslparsertest/glsl2/function-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-05.vert b/tests/glslparsertest/glsl2/function-05.vert
index e8c7b52c..ff224507 100644
--- a/tests/glslparsertest/glsl2/function-05.vert
+++ b/tests/glslparsertest/glsl2/function-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-06.vert b/tests/glslparsertest/glsl2/function-06.vert
index 62207b44..d73ab942 100644
--- a/tests/glslparsertest/glsl2/function-06.vert
+++ b/tests/glslparsertest/glsl2/function-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-07.vert b/tests/glslparsertest/glsl2/function-07.vert
index 3a5a183f..a8c6a16e 100644
--- a/tests/glslparsertest/glsl2/function-07.vert
+++ b/tests/glslparsertest/glsl2/function-07.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-08.frag b/tests/glslparsertest/glsl2/function-08.frag
index ccdccdc6..d784ae08 100644
--- a/tests/glslparsertest/glsl2/function-08.frag
+++ b/tests/glslparsertest/glsl2/function-08.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-09.vert b/tests/glslparsertest/glsl2/function-09.vert
index 7fafe81f..a324dc0c 100644
--- a/tests/glslparsertest/glsl2/function-09.vert
+++ b/tests/glslparsertest/glsl2/function-09.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-10.vert b/tests/glslparsertest/glsl2/function-10.vert
index e785dea8..21d86439 100644
--- a/tests/glslparsertest/glsl2/function-10.vert
+++ b/tests/glslparsertest/glsl2/function-10.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/function-11.vert b/tests/glslparsertest/glsl2/function-11.vert
index 3d4d2ade..0b5c7120 100644
--- a/tests/glslparsertest/glsl2/function-11.vert
+++ b/tests/glslparsertest/glsl2/function-11.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/glsl-pp-elif-no-expression-2.frag b/tests/glslparsertest/glsl2/glsl-pp-elif-no-expression-2.frag
index 3ac3add5..0eb2a9a1 100644
--- a/tests/glslparsertest/glsl2/glsl-pp-elif-no-expression-2.frag
+++ b/tests/glslparsertest/glsl2/glsl-pp-elif-no-expression-2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/gst-gl-cube-v.vert b/tests/glslparsertest/glsl2/gst-gl-cube-v.vert
index 411558d5..b33302c3 100644
--- a/tests/glslparsertest/glsl2/gst-gl-cube-v.vert
+++ b/tests/glslparsertest/glsl2/gst-gl-cube-v.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/gst-gl-mosaic-v.vert b/tests/glslparsertest/glsl2/gst-gl-mosaic-v.vert
index 7c64d601..cb9c623f 100644
--- a/tests/glslparsertest/glsl2/gst-gl-mosaic-v.vert
+++ b/tests/glslparsertest/glsl2/gst-gl-mosaic-v.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/if-01.vert b/tests/glslparsertest/glsl2/if-01.vert
index cdf01940..82bc24a4 100644
--- a/tests/glslparsertest/glsl2/if-01.vert
+++ b/tests/glslparsertest/glsl2/if-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/if-02.vert b/tests/glslparsertest/glsl2/if-02.vert
index c9a1ecf0..688af08f 100644
--- a/tests/glslparsertest/glsl2/if-02.vert
+++ b/tests/glslparsertest/glsl2/if-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/if-03.vert b/tests/glslparsertest/glsl2/if-03.vert
index 98ae050c..86aa62ca 100644
--- a/tests/glslparsertest/glsl2/if-03.vert
+++ b/tests/glslparsertest/glsl2/if-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/if-04.vert b/tests/glslparsertest/glsl2/if-04.vert
index 7c7e7da9..b77d6686 100644
--- a/tests/glslparsertest/glsl2/if-04.vert
+++ b/tests/glslparsertest/glsl2/if-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-02.vert b/tests/glslparsertest/glsl2/implicit-conversion-02.vert
index f8294874..45299434 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-02.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-02.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-03.vert b/tests/glslparsertest/glsl2/implicit-conversion-03.vert
index a919abb9..5c78340c 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-03.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-03.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-04.vert b/tests/glslparsertest/glsl2/implicit-conversion-04.vert
index 93592500..481f64d9 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-04.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-04.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-05.vert b/tests/glslparsertest/glsl2/implicit-conversion-05.vert
index 65bc834c..86766c5d 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-05.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-05.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-06.vert b/tests/glslparsertest/glsl2/implicit-conversion-06.vert
index af2f1ff5..26b745da 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-06.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-06.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-07.vert b/tests/glslparsertest/glsl2/implicit-conversion-07.vert
index 1e5a0d0a..f9fe1212 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-07.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-07.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-08.vert b/tests/glslparsertest/glsl2/implicit-conversion-08.vert
index 5efc04f2..0946e083 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-08.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-08.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-09.vert b/tests/glslparsertest/glsl2/implicit-conversion-09.vert
index 0fa049a9..5473952a 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-09.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-09.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/implicit-conversion-10.vert b/tests/glslparsertest/glsl2/implicit-conversion-10.vert
index 52b0e59a..f27206bc 100644
--- a/tests/glslparsertest/glsl2/implicit-conversion-10.vert
+++ b/tests/glslparsertest/glsl2/implicit-conversion-10.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  */
 #version 120
diff --git a/tests/glslparsertest/glsl2/invariant-01.vert b/tests/glslparsertest/glsl2/invariant-01.vert
index 42355ca6..77d29b3c 100644
--- a/tests/glslparsertest/glsl2/invariant-01.vert
+++ b/tests/glslparsertest/glsl2/invariant-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
@@ -8,7 +9,9 @@
 // [end config]
 
 /* PASS - based on examples in the GLSL 1.20 spec */
+#ifndef GL_ES
 #version 120
+#endif
 
 invariant gl_Position;
 
diff --git a/tests/glslparsertest/glsl2/invariant-03.vert b/tests/glslparsertest/glsl2/invariant-03.vert
index 935b0578..acd9b410 100644
--- a/tests/glslparsertest/glsl2/invariant-03.vert
+++ b/tests/glslparsertest/glsl2/invariant-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/invariant-04.vert b/tests/glslparsertest/glsl2/invariant-04.vert
index 16ad284b..2058969e 100644
--- a/tests/glslparsertest/glsl2/invariant-04.vert
+++ b/tests/glslparsertest/glsl2/invariant-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/invariant-05.vert b/tests/glslparsertest/glsl2/invariant-05.vert
index c1cbc053..f790c527 100644
--- a/tests/glslparsertest/glsl2/invariant-05.vert
+++ b/tests/glslparsertest/glsl2/invariant-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/invariant-06.vert b/tests/glslparsertest/glsl2/invariant-06.vert
index 7d68aa13..5c608aff 100644
--- a/tests/glslparsertest/glsl2/invariant-06.vert
+++ b/tests/glslparsertest/glsl2/invariant-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/invariant-07.vert b/tests/glslparsertest/glsl2/invariant-07.vert
index 2aceb28c..2683ab5d 100644
--- a/tests/glslparsertest/glsl2/invariant-07.vert
+++ b/tests/glslparsertest/glsl2/invariant-07.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/invariant-08.vert b/tests/glslparsertest/glsl2/invariant-08.vert
index 695c575d..2371cab0 100644
--- a/tests/glslparsertest/glsl2/invariant-08.vert
+++ b/tests/glslparsertest/glsl2/invariant-08.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/local-function-01.frag b/tests/glslparsertest/glsl2/local-function-01.frag
index 0ceb4c9c..beaa0991 100644
--- a/tests/glslparsertest/glsl2/local-function-01.frag
+++ b/tests/glslparsertest/glsl2/local-function-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/local-function-02.frag b/tests/glslparsertest/glsl2/local-function-02.frag
index dc52f57b..d5c67bfc 100644
--- a/tests/glslparsertest/glsl2/local-function-02.frag
+++ b/tests/glslparsertest/glsl2/local-function-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/local-function-03.frag b/tests/glslparsertest/glsl2/local-function-03.frag
index 1ee171c2..5c470618 100644
--- a/tests/glslparsertest/glsl2/local-function-03.frag
+++ b/tests/glslparsertest/glsl2/local-function-03.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
@@ -8,7 +9,9 @@
 // [end config]
 
 /* PASS - local function declarations are not allowed in GLSL 1.10. */
+#ifndef GL_ES
 #version 110
+#endif
 void main() {
     float foo(float x);
     gl_FragColor = vec4(0.0, foo(0.5), 0.0, 1.0);
diff --git a/tests/glslparsertest/glsl2/logic-01.frag b/tests/glslparsertest/glsl2/logic-01.frag
index 334213ba..48e87d61 100644
--- a/tests/glslparsertest/glsl2/logic-01.frag
+++ b/tests/glslparsertest/glsl2/logic-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 /* Test short circuit evaluation: though the second argument isn't necessary
diff --git a/tests/glslparsertest/glsl2/logic-02.frag b/tests/glslparsertest/glsl2/logic-02.frag
index 198a54ed..91f85ef3 100644
--- a/tests/glslparsertest/glsl2/logic-02.frag
+++ b/tests/glslparsertest/glsl2/logic-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 /* Test short circuit evaluation: though the second argument isn't necessary
diff --git a/tests/glslparsertest/glsl2/loop-01.vert b/tests/glslparsertest/glsl2/loop-01.vert
index caf3ae85..dbf17dc0 100644
--- a/tests/glslparsertest/glsl2/loop-01.vert
+++ b/tests/glslparsertest/glsl2/loop-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/loop-02.vert b/tests/glslparsertest/glsl2/loop-02.vert
index 10b570e2..9987e41a 100644
--- a/tests/glslparsertest/glsl2/loop-02.vert
+++ b/tests/glslparsertest/glsl2/loop-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/loop-05.vert b/tests/glslparsertest/glsl2/loop-05.vert
index ec07166a..fc28fe11 100644
--- a/tests/glslparsertest/glsl2/loop-05.vert
+++ b/tests/glslparsertest/glsl2/loop-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/loop-06.vert b/tests/glslparsertest/glsl2/loop-06.vert
index bb7e8636..9bc217cf 100644
--- a/tests/glslparsertest/glsl2/loop-06.vert
+++ b/tests/glslparsertest/glsl2/loop-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/loop-07.frag b/tests/glslparsertest/glsl2/loop-07.frag
index 7ff9da45..598af9fb 100644
--- a/tests/glslparsertest/glsl2/loop-07.frag
+++ b/tests/glslparsertest/glsl2/loop-07.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 // [end config]
 
 void main()
diff --git a/tests/glslparsertest/glsl2/matrix-01.vert b/tests/glslparsertest/glsl2/matrix-01.vert
index 29627674..7659c596 100644
--- a/tests/glslparsertest/glsl2/matrix-01.vert
+++ b/tests/glslparsertest/glsl2/matrix-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-02.vert b/tests/glslparsertest/glsl2/matrix-02.vert
index 69eea6fb..c316040b 100644
--- a/tests/glslparsertest/glsl2/matrix-02.vert
+++ b/tests/glslparsertest/glsl2/matrix-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-03.vert b/tests/glslparsertest/glsl2/matrix-03.vert
index fe30f5a2..68f3b11c 100644
--- a/tests/glslparsertest/glsl2/matrix-03.vert
+++ b/tests/glslparsertest/glsl2/matrix-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-04.vert b/tests/glslparsertest/glsl2/matrix-04.vert
index d123313e..2a84ec91 100644
--- a/tests/glslparsertest/glsl2/matrix-04.vert
+++ b/tests/glslparsertest/glsl2/matrix-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-05.vert b/tests/glslparsertest/glsl2/matrix-05.vert
index 9da2b40f..43820600 100644
--- a/tests/glslparsertest/glsl2/matrix-05.vert
+++ b/tests/glslparsertest/glsl2/matrix-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-06.vert b/tests/glslparsertest/glsl2/matrix-06.vert
index 1818f242..3f390e1a 100644
--- a/tests/glslparsertest/glsl2/matrix-06.vert
+++ b/tests/glslparsertest/glsl2/matrix-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-09.vert b/tests/glslparsertest/glsl2/matrix-09.vert
index 2576babf..b4e845c0 100644
--- a/tests/glslparsertest/glsl2/matrix-09.vert
+++ b/tests/glslparsertest/glsl2/matrix-09.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-11.vert b/tests/glslparsertest/glsl2/matrix-11.vert
index c0917c5c..8f63ebcc 100644
--- a/tests/glslparsertest/glsl2/matrix-11.vert
+++ b/tests/glslparsertest/glsl2/matrix-11.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/matrix-12.vert b/tests/glslparsertest/glsl2/matrix-12.vert
index 9cdb58d3..6fd23335 100644
--- a/tests/glslparsertest/glsl2/matrix-12.vert
+++ b/tests/glslparsertest/glsl2/matrix-12.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-01.vert b/tests/glslparsertest/glsl2/parameters-01.vert
index 05252ae3..0ffe8c75 100644
--- a/tests/glslparsertest/glsl2/parameters-01.vert
+++ b/tests/glslparsertest/glsl2/parameters-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-02.vert b/tests/glslparsertest/glsl2/parameters-02.vert
index 413ff734..3afbe8b1 100644
--- a/tests/glslparsertest/glsl2/parameters-02.vert
+++ b/tests/glslparsertest/glsl2/parameters-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-03.vert b/tests/glslparsertest/glsl2/parameters-03.vert
index c92f3dcf..e265f80d 100644
--- a/tests/glslparsertest/glsl2/parameters-03.vert
+++ b/tests/glslparsertest/glsl2/parameters-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-04.vert b/tests/glslparsertest/glsl2/parameters-04.vert
index 75886c0a..b192750b 100644
--- a/tests/glslparsertest/glsl2/parameters-04.vert
+++ b/tests/glslparsertest/glsl2/parameters-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-05.vert b/tests/glslparsertest/glsl2/parameters-05.vert
index 95f33042..4d2ef07e 100644
--- a/tests/glslparsertest/glsl2/parameters-05.vert
+++ b/tests/glslparsertest/glsl2/parameters-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-06.vert b/tests/glslparsertest/glsl2/parameters-06.vert
index 8cf8a437..ca7ce63d 100644
--- a/tests/glslparsertest/glsl2/parameters-06.vert
+++ b/tests/glslparsertest/glsl2/parameters-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-07.vert b/tests/glslparsertest/glsl2/parameters-07.vert
index 6b984056..d83775aa 100644
--- a/tests/glslparsertest/glsl2/parameters-07.vert
+++ b/tests/glslparsertest/glsl2/parameters-07.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/parameters-08.vert b/tests/glslparsertest/glsl2/parameters-08.vert
index 84cfdc56..4bbdaec3 100644
--- a/tests/glslparsertest/glsl2/parameters-08.vert
+++ b/tests/glslparsertest/glsl2/parameters-08.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/pragma-03.vert b/tests/glslparsertest/glsl2/pragma-03.vert
index 8c76bdde..a2d8f9f1 100644
--- a/tests/glslparsertest/glsl2/pragma-03.vert
+++ b/tests/glslparsertest/glsl2/pragma-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/pragma-04.vert b/tests/glslparsertest/glsl2/pragma-04.vert
index c875677d..8cded5ea 100644
--- a/tests/glslparsertest/glsl2/pragma-04.vert
+++ b/tests/glslparsertest/glsl2/pragma-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/pragma-05.vert b/tests/glslparsertest/glsl2/pragma-05.vert
index fed784bc..3119a0bf 100644
--- a/tests/glslparsertest/glsl2/pragma-05.vert
+++ b/tests/glslparsertest/glsl2/pragma-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/pragma-06.vert b/tests/glslparsertest/glsl2/pragma-06.vert
index d6cbc24f..6a6d14b5 100644
--- a/tests/glslparsertest/glsl2/pragma-06.vert
+++ b/tests/glslparsertest/glsl2/pragma-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/precision-01.vert b/tests/glslparsertest/glsl2/precision-01.vert
index 8dd7a0bb..94215239 100644
--- a/tests/glslparsertest/glsl2/precision-01.vert
+++ b/tests/glslparsertest/glsl2/precision-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/preprocessor-01.frag b/tests/glslparsertest/glsl2/preprocessor-01.frag
index a8bc55d5..f9a9bd22 100644
--- a/tests/glslparsertest/glsl2/preprocessor-01.frag
+++ b/tests/glslparsertest/glsl2/preprocessor-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-01.vert b/tests/glslparsertest/glsl2/redeclaration-01.vert
index 9292b07f..26a231ff 100644
--- a/tests/glslparsertest/glsl2/redeclaration-01.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-02.vert b/tests/glslparsertest/glsl2/redeclaration-02.vert
index 70541feb..f010b5a2 100644
--- a/tests/glslparsertest/glsl2/redeclaration-02.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-02.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-03.vert b/tests/glslparsertest/glsl2/redeclaration-03.vert
index 14084efa..37d4423f 100644
--- a/tests/glslparsertest/glsl2/redeclaration-03.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-03.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-04.vert b/tests/glslparsertest/glsl2/redeclaration-04.vert
index 4bd8e15e..1535ae28 100644
--- a/tests/glslparsertest/glsl2/redeclaration-04.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-04.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-05.vert b/tests/glslparsertest/glsl2/redeclaration-05.vert
index 6d4a6076..0738d8e5 100644
--- a/tests/glslparsertest/glsl2/redeclaration-05.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-06.vert b/tests/glslparsertest/glsl2/redeclaration-06.vert
index 2c91b1fe..fc08b5ea 100644
--- a/tests/glslparsertest/glsl2/redeclaration-06.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-06.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-07.vert b/tests/glslparsertest/glsl2/redeclaration-07.vert
index 321e75e4..2b4c123d 100644
--- a/tests/glslparsertest/glsl2/redeclaration-07.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-07.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-08.vert b/tests/glslparsertest/glsl2/redeclaration-08.vert
index db1e5bc9..01bd946d 100644
--- a/tests/glslparsertest/glsl2/redeclaration-08.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-08.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-09.vert b/tests/glslparsertest/glsl2/redeclaration-09.vert
index 531f6aa6..e4445c86 100644
--- a/tests/glslparsertest/glsl2/redeclaration-09.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-09.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-10.vert b/tests/glslparsertest/glsl2/redeclaration-10.vert
index 5f79df1a..023bd2fc 100644
--- a/tests/glslparsertest/glsl2/redeclaration-10.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-10.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-11.vert b/tests/glslparsertest/glsl2/redeclaration-11.vert
index b566cad2..a5f9dabf 100644
--- a/tests/glslparsertest/glsl2/redeclaration-11.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-11.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-12.vert b/tests/glslparsertest/glsl2/redeclaration-12.vert
index 19dcd4a6..6f223d2a 100644
--- a/tests/glslparsertest/glsl2/redeclaration-12.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-12.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-13.vert b/tests/glslparsertest/glsl2/redeclaration-13.vert
index 761edb32..fce36576 100644
--- a/tests/glslparsertest/glsl2/redeclaration-13.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-13.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-15.vert b/tests/glslparsertest/glsl2/redeclaration-15.vert
index 6aa1226c..2ad25c63 100644
--- a/tests/glslparsertest/glsl2/redeclaration-15.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-15.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.20
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-16.vert b/tests/glslparsertest/glsl2/redeclaration-16.vert
index f1443a97..c6a889b5 100644
--- a/tests/glslparsertest/glsl2/redeclaration-16.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-16.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-17.vert b/tests/glslparsertest/glsl2/redeclaration-17.vert
index c53f50c8..c2729010 100644
--- a/tests/glslparsertest/glsl2/redeclaration-17.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-17.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-18.vert b/tests/glslparsertest/glsl2/redeclaration-18.vert
index ddbd845a..306b0d66 100644
--- a/tests/glslparsertest/glsl2/redeclaration-18.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-18.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/redeclaration-19.vert b/tests/glslparsertest/glsl2/redeclaration-19.vert
index d4d702b0..0f1aea4d 100644
--- a/tests/glslparsertest/glsl2/redeclaration-19.vert
+++ b/tests/glslparsertest/glsl2/redeclaration-19.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/return-conversion-03.vert b/tests/glslparsertest/glsl2/return-conversion-03.vert
index 0d5aa403..3d830c5f 100644
--- a/tests/glslparsertest/glsl2/return-conversion-03.vert
+++ b/tests/glslparsertest/glsl2/return-conversion-03.vert
@@ -1,6 +1,7 @@
 /* [config]
  * expect_result: fail
  * glsl_version: 1.20
+// glsles_version: 1.00
  * [end config]
  *
  * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
diff --git a/tests/glslparsertest/glsl2/return-conversion-2.frag b/tests/glslparsertest/glsl2/return-conversion-2.frag
index 5d9ce79c..f97c28aa 100644
--- a/tests/glslparsertest/glsl2/return-conversion-2.frag
+++ b/tests/glslparsertest/glsl2/return-conversion-2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/return-conversion.frag b/tests/glslparsertest/glsl2/return-conversion.frag
index a0be87a5..e7bf8419 100644
--- a/tests/glslparsertest/glsl2/return-conversion.frag
+++ b/tests/glslparsertest/glsl2/return-conversion.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/return-qualifier.frag b/tests/glslparsertest/glsl2/return-qualifier.frag
index 886d5435..9ad8e2ba 100644
--- a/tests/glslparsertest/glsl2/return-qualifier.frag
+++ b/tests/glslparsertest/glsl2/return-qualifier.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/sampler-01.frag b/tests/glslparsertest/glsl2/sampler-01.frag
index a6c54d2e..1c8e40e2 100644
--- a/tests/glslparsertest/glsl2/sampler-01.frag
+++ b/tests/glslparsertest/glsl2/sampler-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/sampler-02.frag b/tests/glslparsertest/glsl2/sampler-02.frag
index 62c03e50..2be2af28 100644
--- a/tests/glslparsertest/glsl2/sampler-02.frag
+++ b/tests/glslparsertest/glsl2/sampler-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/sampler-03.frag b/tests/glslparsertest/glsl2/sampler-03.frag
index e4a94d13..e46aa4c3 100644
--- a/tests/glslparsertest/glsl2/sampler-03.frag
+++ b/tests/glslparsertest/glsl2/sampler-03.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/sampler-04.frag b/tests/glslparsertest/glsl2/sampler-04.frag
index 22b1b244..2c81931b 100644
--- a/tests/glslparsertest/glsl2/sampler-04.frag
+++ b/tests/glslparsertest/glsl2/sampler-04.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/sampler-05.frag b/tests/glslparsertest/glsl2/sampler-05.frag
index 45cdf13c..bb4e4f36 100644
--- a/tests/glslparsertest/glsl2/sampler-05.frag
+++ b/tests/glslparsertest/glsl2/sampler-05.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/sampler-06.frag b/tests/glslparsertest/glsl2/sampler-06.frag
index 76a2bbfb..ad2ec672 100644
--- a/tests/glslparsertest/glsl2/sampler-06.frag
+++ b/tests/glslparsertest/glsl2/sampler-06.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/scoping-01.frag b/tests/glslparsertest/glsl2/scoping-01.frag
index d95fba78..042d4b8c 100644
--- a/tests/glslparsertest/glsl2/scoping-01.frag
+++ b/tests/glslparsertest/glsl2/scoping-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/scoping-02.frag b/tests/glslparsertest/glsl2/scoping-02.frag
index b9f0774c..36518d93 100644
--- a/tests/glslparsertest/glsl2/scoping-02.frag
+++ b/tests/glslparsertest/glsl2/scoping-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/struct-01.vert b/tests/glslparsertest/glsl2/struct-01.vert
index 0b18953d..aa4f9dbc 100644
--- a/tests/glslparsertest/glsl2/struct-01.vert
+++ b/tests/glslparsertest/glsl2/struct-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/struct-02.vert b/tests/glslparsertest/glsl2/struct-02.vert
index 5a2c2912..125ff862 100644
--- a/tests/glslparsertest/glsl2/struct-02.vert
+++ b/tests/glslparsertest/glsl2/struct-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/struct-05.vert b/tests/glslparsertest/glsl2/struct-05.vert
index 42094b54..3f2a4cbc 100644
--- a/tests/glslparsertest/glsl2/struct-05.vert
+++ b/tests/glslparsertest/glsl2/struct-05.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/struct-06.frag b/tests/glslparsertest/glsl2/struct-06.frag
index 21dc7997..49db844d 100644
--- a/tests/glslparsertest/glsl2/struct-06.frag
+++ b/tests/glslparsertest/glsl2/struct-06.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/swiz-01.vert b/tests/glslparsertest/glsl2/swiz-01.vert
index 46436079..0a46a95f 100644
--- a/tests/glslparsertest/glsl2/swiz-01.vert
+++ b/tests/glslparsertest/glsl2/swiz-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/swiz-02.vert b/tests/glslparsertest/glsl2/swiz-02.vert
index 528ed2a6..2cbb9078 100644
--- a/tests/glslparsertest/glsl2/swiz-02.vert
+++ b/tests/glslparsertest/glsl2/swiz-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-01.frag b/tests/glslparsertest/glsl2/tex_lod-01.frag
index 9be11ba5..641093e6 100644
--- a/tests/glslparsertest/glsl2/tex_lod-01.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-01.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-02.frag b/tests/glslparsertest/glsl2/tex_lod-02.frag
index f957360e..25d5d7a9 100644
--- a/tests/glslparsertest/glsl2/tex_lod-02.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-03.frag b/tests/glslparsertest/glsl2/tex_lod-03.frag
index 0918db64..d535e8ce 100644
--- a/tests/glslparsertest/glsl2/tex_lod-03.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-03.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-04.frag b/tests/glslparsertest/glsl2/tex_lod-04.frag
index fe195639..96383c1b 100644
--- a/tests/glslparsertest/glsl2/tex_lod-04.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-04.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-05.frag b/tests/glslparsertest/glsl2/tex_lod-05.frag
index 3c6cf283..a55f53fb 100644
--- a/tests/glslparsertest/glsl2/tex_lod-05.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-05.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-06.frag b/tests/glslparsertest/glsl2/tex_lod-06.frag
index b50304f4..2bd99894 100644
--- a/tests/glslparsertest/glsl2/tex_lod-06.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-06.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-07.frag b/tests/glslparsertest/glsl2/tex_lod-07.frag
index 819b5d8a..6794168c 100644
--- a/tests/glslparsertest/glsl2/tex_lod-07.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-07.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-08.frag b/tests/glslparsertest/glsl2/tex_lod-08.frag
index ed989b89..0a644a7e 100644
--- a/tests/glslparsertest/glsl2/tex_lod-08.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-08.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-09.frag b/tests/glslparsertest/glsl2/tex_lod-09.frag
index 13cbdbde..9a503b81 100644
--- a/tests/glslparsertest/glsl2/tex_lod-09.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-09.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-10.frag b/tests/glslparsertest/glsl2/tex_lod-10.frag
index e337d2bb..5c2f803e 100644
--- a/tests/glslparsertest/glsl2/tex_lod-10.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-10.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-11.frag b/tests/glslparsertest/glsl2/tex_lod-11.frag
index 6bc5d1f5..d176ee10 100644
--- a/tests/glslparsertest/glsl2/tex_lod-11.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-11.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-12.frag b/tests/glslparsertest/glsl2/tex_lod-12.frag
index 7a43cc69..1e7b8244 100644
--- a/tests/glslparsertest/glsl2/tex_lod-12.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-12.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_lod-13.frag b/tests/glslparsertest/glsl2/tex_lod-13.frag
index 6b3ec4b3..be5b29fe 100644
--- a/tests/glslparsertest/glsl2/tex_lod-13.frag
+++ b/tests/glslparsertest/glsl2/tex_lod-13.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_rect-01.frag b/tests/glslparsertest/glsl2/tex_rect-01.frag
index bdddb499..bb37c816 100644
--- a/tests/glslparsertest/glsl2/tex_rect-01.frag
+++ b/tests/glslparsertest/glsl2/tex_rect-01.frag
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_rect-02.frag b/tests/glslparsertest/glsl2/tex_rect-02.frag
index 9a51cef1..29cc70f0 100644
--- a/tests/glslparsertest/glsl2/tex_rect-02.frag
+++ b/tests/glslparsertest/glsl2/tex_rect-02.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/tex_rect-03.frag b/tests/glslparsertest/glsl2/tex_rect-03.frag
index ab2376ad..0f4dfa64 100644
--- a/tests/glslparsertest/glsl2/tex_rect-03.frag
+++ b/tests/glslparsertest/glsl2/tex_rect-03.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/unary-plus.frag b/tests/glslparsertest/glsl2/unary-plus.frag
index 1d418411..67cee53e 100644
--- a/tests/glslparsertest/glsl2/unary-plus.frag
+++ b/tests/glslparsertest/glsl2/unary-plus.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/uniform-02.vert b/tests/glslparsertest/glsl2/uniform-02.vert
index b5152965..c332b091 100644
--- a/tests/glslparsertest/glsl2/uniform-02.vert
+++ b/tests/glslparsertest/glsl2/uniform-02.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/unsized-array-non-const-index.vert b/tests/glslparsertest/glsl2/unsized-array-non-const-index.vert
index e146722d..c7d2453c 100644
--- a/tests/glslparsertest/glsl2/unsized-array-non-const-index.vert
+++ b/tests/glslparsertest/glsl2/unsized-array-non-const-index.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/void-01.vert b/tests/glslparsertest/glsl2/void-01.vert
index 311f0d5e..cb1c09eb 100644
--- a/tests/glslparsertest/glsl2/void-01.vert
+++ b/tests/glslparsertest/glsl2/void-01.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/xreal-lighting-d-omni.frag b/tests/glslparsertest/glsl2/xreal-lighting-d-omni.frag
index e386e5b0..5bd24df9 100644
--- a/tests/glslparsertest/glsl2/xreal-lighting-d-omni.frag
+++ b/tests/glslparsertest/glsl2/xreal-lighting-d-omni.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/xreal-lighting-db-omni.frag b/tests/glslparsertest/glsl2/xreal-lighting-db-omni.frag
index e6e512fb..016ce645 100644
--- a/tests/glslparsertest/glsl2/xreal-lighting-db-omni.frag
+++ b/tests/glslparsertest/glsl2/xreal-lighting-db-omni.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/glsl2/xreal-lighting-dbs-omni.frag b/tests/glslparsertest/glsl2/xreal-lighting-dbs-omni.frag
index 5e087970..74f44cea 100644
--- a/tests/glslparsertest/glsl2/xreal-lighting-dbs-omni.frag
+++ b/tests/glslparsertest/glsl2/xreal-lighting-dbs-omni.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CGDataTypes.frag b/tests/glslparsertest/shaders/CGDataTypes.frag
index bda4a819..d144b070 100644
--- a/tests/glslparsertest/shaders/CGDataTypes.frag
+++ b/tests/glslparsertest/shaders/CGDataTypes.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CGStandardLibrary.frag b/tests/glslparsertest/shaders/CGStandardLibrary.frag
index b9b00dd2..44c872cf 100644
--- a/tests/glslparsertest/shaders/CGStandardLibrary.frag
+++ b/tests/glslparsertest/shaders/CGStandardLibrary.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/ConstantConversions.frag b/tests/glslparsertest/shaders/ConstantConversions.frag
index 9deeed6a..a9e026f4 100644
--- a/tests/glslparsertest/shaders/ConstantConversions.frag
+++ b/tests/glslparsertest/shaders/ConstantConversions.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectBuiltInOveride.frag b/tests/glslparsertest/shaders/CorrectBuiltInOveride.frag
index 94716fe7..69733de8 100644
--- a/tests/glslparsertest/shaders/CorrectBuiltInOveride.frag
+++ b/tests/glslparsertest/shaders/CorrectBuiltInOveride.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectComma.frag b/tests/glslparsertest/shaders/CorrectComma.frag
index 69290c42..e3bf0f12 100644
--- a/tests/glslparsertest/shaders/CorrectComma.frag
+++ b/tests/glslparsertest/shaders/CorrectComma.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectConstFolding1.vert b/tests/glslparsertest/shaders/CorrectConstFolding1.vert
index d50f9607..36d423a2 100644
--- a/tests/glslparsertest/shaders/CorrectConstFolding1.vert
+++ b/tests/glslparsertest/shaders/CorrectConstFolding1.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectConstFolding2.vert b/tests/glslparsertest/shaders/CorrectConstFolding2.vert
index 10526aa2..e53a4e27 100644
--- a/tests/glslparsertest/shaders/CorrectConstFolding2.vert
+++ b/tests/glslparsertest/shaders/CorrectConstFolding2.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectConstruct.vert b/tests/glslparsertest/shaders/CorrectConstruct.vert
index a5c36466..e59404ba 100644
--- a/tests/glslparsertest/shaders/CorrectConstruct.vert
+++ b/tests/glslparsertest/shaders/CorrectConstruct.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectExtension1.V110.frag b/tests/glslparsertest/shaders/CorrectExtension1.V110.frag
index f2210262..b98370f6 100644
--- a/tests/glslparsertest/shaders/CorrectExtension1.V110.frag
+++ b/tests/glslparsertest/shaders/CorrectExtension1.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectExtension10.V110.frag b/tests/glslparsertest/shaders/CorrectExtension10.V110.frag
index 853ec09e..e049cf00 100644
--- a/tests/glslparsertest/shaders/CorrectExtension10.V110.frag
+++ b/tests/glslparsertest/shaders/CorrectExtension10.V110.frag
@@ -1,13 +1,19 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
 // # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
 // [end config]
 
+#ifndef GL_ES
 #version 110

+#else
+#version 100
+#endif
+
 #extension extensionfoo : enable  // warning extension not supported 

 #extension extensionfoo : disable  // warning extension not supported 

 #extension extensionfoo : warn  // warning extension not supported 

diff --git a/tests/glslparsertest/shaders/CorrectExtension4.V110.frag b/tests/glslparsertest/shaders/CorrectExtension4.V110.frag
index ebf1a16e..7495786a 100644
--- a/tests/glslparsertest/shaders/CorrectExtension4.V110.frag
+++ b/tests/glslparsertest/shaders/CorrectExtension4.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectFull.frag b/tests/glslparsertest/shaders/CorrectFull.frag
index a3f1fe9c..75e72ccd 100644
--- a/tests/glslparsertest/shaders/CorrectFull.frag
+++ b/tests/glslparsertest/shaders/CorrectFull.frag
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectFull.vert b/tests/glslparsertest/shaders/CorrectFull.vert
index 7a56f463..b6db786a 100644
--- a/tests/glslparsertest/shaders/CorrectFull.vert
+++ b/tests/glslparsertest/shaders/CorrectFull.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectFuncOverload.frag b/tests/glslparsertest/shaders/CorrectFuncOverload.frag
index 8163ce69..404824a0 100644
--- a/tests/glslparsertest/shaders/CorrectFuncOverload.frag
+++ b/tests/glslparsertest/shaders/CorrectFuncOverload.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectFuncOverload.vert b/tests/glslparsertest/shaders/CorrectFuncOverload.vert
index 097cdf08..e72448b2 100644
--- a/tests/glslparsertest/shaders/CorrectFuncOverload.vert
+++ b/tests/glslparsertest/shaders/CorrectFuncOverload.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectFunction.vert b/tests/glslparsertest/shaders/CorrectFunction.vert
index b8873b35..bcb872a5 100644
--- a/tests/glslparsertest/shaders/CorrectFunction.vert
+++ b/tests/glslparsertest/shaders/CorrectFunction.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectFunction1.vert b/tests/glslparsertest/shaders/CorrectFunction1.vert
index 83f32eda..e79ae8fa 100644
--- a/tests/glslparsertest/shaders/CorrectFunction1.vert
+++ b/tests/glslparsertest/shaders/CorrectFunction1.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectMatComma.frag b/tests/glslparsertest/shaders/CorrectMatComma.frag
index 156155c5..2a40cc7a 100644
--- a/tests/glslparsertest/shaders/CorrectMatComma.frag
+++ b/tests/glslparsertest/shaders/CorrectMatComma.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectMatComma2.frag b/tests/glslparsertest/shaders/CorrectMatComma2.frag
index 08ddd97a..eac22411 100644
--- a/tests/glslparsertest/shaders/CorrectMatComma2.frag
+++ b/tests/glslparsertest/shaders/CorrectMatComma2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectModule.frag b/tests/glslparsertest/shaders/CorrectModule.frag
index e1cb2d59..b1ab6c95 100644
--- a/tests/glslparsertest/shaders/CorrectModule.frag
+++ b/tests/glslparsertest/shaders/CorrectModule.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectParse1.frag b/tests/glslparsertest/shaders/CorrectParse1.frag
index 03ae5c3b..7b0be83f 100644
--- a/tests/glslparsertest/shaders/CorrectParse1.frag
+++ b/tests/glslparsertest/shaders/CorrectParse1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectParse2.frag b/tests/glslparsertest/shaders/CorrectParse2.frag
index edf1d68c..1b94c766 100644
--- a/tests/glslparsertest/shaders/CorrectParse2.frag
+++ b/tests/glslparsertest/shaders/CorrectParse2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectParse2.vert b/tests/glslparsertest/shaders/CorrectParse2.vert
index 68fc51bb..aa937cfb 100644
--- a/tests/glslparsertest/shaders/CorrectParse2.vert
+++ b/tests/glslparsertest/shaders/CorrectParse2.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectParseTest.frag b/tests/glslparsertest/shaders/CorrectParseTest.frag
index 0ee187bd..19ce4432 100644
--- a/tests/glslparsertest/shaders/CorrectParseTest.frag
+++ b/tests/glslparsertest/shaders/CorrectParseTest.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectParseTest1.frag b/tests/glslparsertest/shaders/CorrectParseTest1.frag
index 0ec37488..64cf6af7 100644
--- a/tests/glslparsertest/shaders/CorrectParseTest1.frag
+++ b/tests/glslparsertest/shaders/CorrectParseTest1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectPreprocess5.frag b/tests/glslparsertest/shaders/CorrectPreprocess5.frag
index c8edfa13..ccb3d7b4 100644
--- a/tests/glslparsertest/shaders/CorrectPreprocess5.frag
+++ b/tests/glslparsertest/shaders/CorrectPreprocess5.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectPreprocess8.frag b/tests/glslparsertest/shaders/CorrectPreprocess8.frag
index 0aa91163..fc6649ae 100644
--- a/tests/glslparsertest/shaders/CorrectPreprocess8.frag
+++ b/tests/glslparsertest/shaders/CorrectPreprocess8.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectPreprocess9.frag b/tests/glslparsertest/shaders/CorrectPreprocess9.frag
index 468258ae..b4305159 100644
--- a/tests/glslparsertest/shaders/CorrectPreprocess9.frag
+++ b/tests/glslparsertest/shaders/CorrectPreprocess9.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectReservedWords.frag b/tests/glslparsertest/shaders/CorrectReservedWords.frag
index 9fdcafa6..e215d158 100644
--- a/tests/glslparsertest/shaders/CorrectReservedWords.frag
+++ b/tests/glslparsertest/shaders/CorrectReservedWords.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectScalarVectorExpressions.frag b/tests/glslparsertest/shaders/CorrectScalarVectorExpressions.frag
index a676e974..c07814c0 100644
--- a/tests/glslparsertest/shaders/CorrectScalarVectorExpressions.frag
+++ b/tests/glslparsertest/shaders/CorrectScalarVectorExpressions.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectSwizzle1.frag b/tests/glslparsertest/shaders/CorrectSwizzle1.frag
index 0d50a226..d7321a03 100644
--- a/tests/glslparsertest/shaders/CorrectSwizzle1.frag
+++ b/tests/glslparsertest/shaders/CorrectSwizzle1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectSwizzle1.vert b/tests/glslparsertest/shaders/CorrectSwizzle1.vert
index fd6b50ab..4aa753d1 100644
--- a/tests/glslparsertest/shaders/CorrectSwizzle1.vert
+++ b/tests/glslparsertest/shaders/CorrectSwizzle1.vert
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectSwizzle2.frag b/tests/glslparsertest/shaders/CorrectSwizzle2.frag
index 59bec210..c5aac69a 100644
--- a/tests/glslparsertest/shaders/CorrectSwizzle2.frag
+++ b/tests/glslparsertest/shaders/CorrectSwizzle2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectSwizzle2.vert b/tests/glslparsertest/shaders/CorrectSwizzle2.vert
index d763ccf8..e93d1a5f 100644
--- a/tests/glslparsertest/shaders/CorrectSwizzle2.vert
+++ b/tests/glslparsertest/shaders/CorrectSwizzle2.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectSwizzle3.frag b/tests/glslparsertest/shaders/CorrectSwizzle3.frag
index 7bf9ebd5..d59a48c2 100644
--- a/tests/glslparsertest/shaders/CorrectSwizzle3.frag
+++ b/tests/glslparsertest/shaders/CorrectSwizzle3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: pass
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectUnsizedArray.frag b/tests/glslparsertest/shaders/CorrectUnsizedArray.frag
index 256c7f8d..0dda33ec 100644
--- a/tests/glslparsertest/shaders/CorrectUnsizedArray.frag
+++ b/tests/glslparsertest/shaders/CorrectUnsizedArray.frag
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/CorrectVersion.V100.frag b/tests/glslparsertest/shaders/CorrectVersion.V100.frag
new file mode 100644
index 00000000..471a5284
--- /dev/null
+++ b/tests/glslparsertest/shaders/CorrectVersion.V100.frag
@@ -0,0 +1,22 @@
+// [config]
+// expect_result: pass
+// glsl_version: 1.10
+// glsles_version: 1.00
+//
+// # NOTE: Config section was auto-generated from file
+// # NOTE: 'glslparser.tests' at git revision
+// # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
+// [end config]
+
+/* #version can only be followed by number 100. The only statements before
+   #version can be comment or white spaces */
+
+
+
+#version 100
+
+
+void main()
+{
+   gl_FragColor = vec4(1);
+}
diff --git a/tests/glslparsertest/shaders/CorrectVersion1.V100.frag b/tests/glslparsertest/shaders/CorrectVersion1.V100.frag
new file mode 100644
index 00000000..a91aec0f
--- /dev/null
+++ b/tests/glslparsertest/shaders/CorrectVersion1.V100.frag
@@ -0,0 +1,18 @@
+// [config]
+// expect_result: fail
+// glsl_version: 1.10
+// glsles_version: 1.00
+//
+// # NOTE: Config section was auto-generated from file
+// # NOTE: 'glslparser.tests' at git revision
+// # NOTE: 6cc17ae70b70d150aa1751f8e28db7b2a9bd50f0
+// [end config]
+
+/* Only one version statement is allowed; two should raise an error. */
+#version 100
+#version 100
+
+void main()
+{
+   gl_FragColor = vec4(1);
+}
diff --git a/tests/glslparsertest/shaders/FunctionParam.vert b/tests/glslparsertest/shaders/FunctionParam.vert
index 687e30bd..87c79eba 100644
--- a/tests/glslparsertest/shaders/FunctionParam.vert
+++ b/tests/glslparsertest/shaders/FunctionParam.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/IncludeDirective.frag b/tests/glslparsertest/shaders/IncludeDirective.frag
index 3fafcba9..df776e81 100644
--- a/tests/glslparsertest/shaders/IncludeDirective.frag
+++ b/tests/glslparsertest/shaders/IncludeDirective.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/MainParameters.vert b/tests/glslparsertest/shaders/MainParameters.vert
index 2ecc5831..d6c91090 100644
--- a/tests/glslparsertest/shaders/MainParameters.vert
+++ b/tests/glslparsertest/shaders/MainParameters.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/ParseTest3.frag b/tests/glslparsertest/shaders/ParseTest3.frag
index d9fb1685..363d6f2a 100644
--- a/tests/glslparsertest/shaders/ParseTest3.frag
+++ b/tests/glslparsertest/shaders/ParseTest3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/ParseTest4.frag b/tests/glslparsertest/shaders/ParseTest4.frag
index 5acee308..d91ee17c 100644
--- a/tests/glslparsertest/shaders/ParseTest4.frag
+++ b/tests/glslparsertest/shaders/ParseTest4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/TernaryOp.frag b/tests/glslparsertest/shaders/TernaryOp.frag
index 475924b8..4867a2c1 100644
--- a/tests/glslparsertest/shaders/TernaryOp.frag
+++ b/tests/glslparsertest/shaders/TernaryOp.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/TextureRectangleSamplers.frag b/tests/glslparsertest/shaders/TextureRectangleSamplers.frag
index a278def3..2a4764e2 100644
--- a/tests/glslparsertest/shaders/TextureRectangleSamplers.frag
+++ b/tests/glslparsertest/shaders/TextureRectangleSamplers.frag
@@ -1,6 +1,8 @@
 // [config]
 // expect_result: pass
+// glsles_expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array1.frag b/tests/glslparsertest/shaders/array1.frag
index 76270916..c36597b6 100644
--- a/tests/glslparsertest/shaders/array1.frag
+++ b/tests/glslparsertest/shaders/array1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array10.frag b/tests/glslparsertest/shaders/array10.frag
index f5287248..b0c7be79 100644
--- a/tests/glslparsertest/shaders/array10.frag
+++ b/tests/glslparsertest/shaders/array10.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array11.frag b/tests/glslparsertest/shaders/array11.frag
index 431d8c44..48dddcef 100644
--- a/tests/glslparsertest/shaders/array11.frag
+++ b/tests/glslparsertest/shaders/array11.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array2.frag b/tests/glslparsertest/shaders/array2.frag
index 3b64810f..35916a6b 100644
--- a/tests/glslparsertest/shaders/array2.frag
+++ b/tests/glslparsertest/shaders/array2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array3.frag b/tests/glslparsertest/shaders/array3.frag
index 65d83ebf..f49f23c1 100644
--- a/tests/glslparsertest/shaders/array3.frag
+++ b/tests/glslparsertest/shaders/array3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array4.frag b/tests/glslparsertest/shaders/array4.frag
index 45118cae..915a6317 100644
--- a/tests/glslparsertest/shaders/array4.frag
+++ b/tests/glslparsertest/shaders/array4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array5.frag b/tests/glslparsertest/shaders/array5.frag
index c0fe9d8a..234de0bb 100644
--- a/tests/glslparsertest/shaders/array5.frag
+++ b/tests/glslparsertest/shaders/array5.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array6.frag b/tests/glslparsertest/shaders/array6.frag
index 15778323..29875093 100644
--- a/tests/glslparsertest/shaders/array6.frag
+++ b/tests/glslparsertest/shaders/array6.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array7.frag b/tests/glslparsertest/shaders/array7.frag
index 7ccb10c3..7ba1ccfe 100644
--- a/tests/glslparsertest/shaders/array7.frag
+++ b/tests/glslparsertest/shaders/array7.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array8.frag b/tests/glslparsertest/shaders/array8.frag
index 095e9087..e8e6d575 100644
--- a/tests/glslparsertest/shaders/array8.frag
+++ b/tests/glslparsertest/shaders/array8.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/array9.frag b/tests/glslparsertest/shaders/array9.frag
index 050e78af..9409c755 100644
--- a/tests/glslparsertest/shaders/array9.frag
+++ b/tests/glslparsertest/shaders/array9.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/attribute.frag b/tests/glslparsertest/shaders/attribute.frag
index 41b19ff9..de76bd63 100644
--- a/tests/glslparsertest/shaders/attribute.frag
+++ b/tests/glslparsertest/shaders/attribute.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/attribute.vert b/tests/glslparsertest/shaders/attribute.vert
index 30bee985..4e4d4cfd 100644
--- a/tests/glslparsertest/shaders/attribute.vert
+++ b/tests/glslparsertest/shaders/attribute.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/attribute1.vert b/tests/glslparsertest/shaders/attribute1.vert
index bd69f982..e37685e9 100644
--- a/tests/glslparsertest/shaders/attribute1.vert
+++ b/tests/glslparsertest/shaders/attribute1.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/attribute2.vert b/tests/glslparsertest/shaders/attribute2.vert
index 8dc8438f..25c6ec66 100644
--- a/tests/glslparsertest/shaders/attribute2.vert
+++ b/tests/glslparsertest/shaders/attribute2.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/break.frag b/tests/glslparsertest/shaders/break.frag
index 39c1818e..afb543d6 100644
--- a/tests/glslparsertest/shaders/break.frag
+++ b/tests/glslparsertest/shaders/break.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/comma1.vert b/tests/glslparsertest/shaders/comma1.vert
index 91d95f92..e2a97135 100644
--- a/tests/glslparsertest/shaders/comma1.vert
+++ b/tests/glslparsertest/shaders/comma1.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/comma2.frag b/tests/glslparsertest/shaders/comma2.frag
index e15d31fb..02a95b63 100644
--- a/tests/glslparsertest/shaders/comma2.frag
+++ b/tests/glslparsertest/shaders/comma2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/comma2.vert b/tests/glslparsertest/shaders/comma2.vert
index 43e71ab4..09d88260 100644
--- a/tests/glslparsertest/shaders/comma2.vert
+++ b/tests/glslparsertest/shaders/comma2.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/comma3.vert b/tests/glslparsertest/shaders/comma3.vert
index 863ec780..620de9be 100644
--- a/tests/glslparsertest/shaders/comma3.vert
+++ b/tests/glslparsertest/shaders/comma3.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/comment.frag b/tests/glslparsertest/shaders/comment.frag
index 1636e4c6..c66160d5 100644
--- a/tests/glslparsertest/shaders/comment.frag
+++ b/tests/glslparsertest/shaders/comment.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/conditional1.frag b/tests/glslparsertest/shaders/conditional1.frag
index c831ba92..f75147a8 100644
--- a/tests/glslparsertest/shaders/conditional1.frag
+++ b/tests/glslparsertest/shaders/conditional1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/conditional2.frag b/tests/glslparsertest/shaders/conditional2.frag
index dd4e9003..78c639d1 100644
--- a/tests/glslparsertest/shaders/conditional2.frag
+++ b/tests/glslparsertest/shaders/conditional2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/conditional3.frag b/tests/glslparsertest/shaders/conditional3.frag
index af71794b..f64eaef5 100644
--- a/tests/glslparsertest/shaders/conditional3.frag
+++ b/tests/glslparsertest/shaders/conditional3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/constFunc.frag b/tests/glslparsertest/shaders/constFunc.frag
index 911668c3..add5a4a9 100644
--- a/tests/glslparsertest/shaders/constFunc.frag
+++ b/tests/glslparsertest/shaders/constFunc.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/constructor1.frag b/tests/glslparsertest/shaders/constructor1.frag
index 0ffc3d5c..17a23553 100644
--- a/tests/glslparsertest/shaders/constructor1.frag
+++ b/tests/glslparsertest/shaders/constructor1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/constructor2.frag b/tests/glslparsertest/shaders/constructor2.frag
index d4abba9d..d0905430 100644
--- a/tests/glslparsertest/shaders/constructor2.frag
+++ b/tests/glslparsertest/shaders/constructor2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/constructor3.V110.frag b/tests/glslparsertest/shaders/constructor3.V110.frag
index f13bab31..f77dc873 100644
--- a/tests/glslparsertest/shaders/constructor3.V110.frag
+++ b/tests/glslparsertest/shaders/constructor3.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/continue.frag b/tests/glslparsertest/shaders/continue.frag
index 5fac3ec3..5d3e86bb 100644
--- a/tests/glslparsertest/shaders/continue.frag
+++ b/tests/glslparsertest/shaders/continue.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType1.frag b/tests/glslparsertest/shaders/dataType1.frag
index fa02b60d..b2f8db2a 100644
--- a/tests/glslparsertest/shaders/dataType1.frag
+++ b/tests/glslparsertest/shaders/dataType1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType10.frag b/tests/glslparsertest/shaders/dataType10.frag
index 685d7153..7facd3af 100644
--- a/tests/glslparsertest/shaders/dataType10.frag
+++ b/tests/glslparsertest/shaders/dataType10.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType11.frag b/tests/glslparsertest/shaders/dataType11.frag
index 257b5685..ae54e18e 100644
--- a/tests/glslparsertest/shaders/dataType11.frag
+++ b/tests/glslparsertest/shaders/dataType11.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType12.frag b/tests/glslparsertest/shaders/dataType12.frag
index fb18ad22..78ad0baf 100644
--- a/tests/glslparsertest/shaders/dataType12.frag
+++ b/tests/glslparsertest/shaders/dataType12.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType13.frag b/tests/glslparsertest/shaders/dataType13.frag
index b64d0192..20a86ca9 100644
--- a/tests/glslparsertest/shaders/dataType13.frag
+++ b/tests/glslparsertest/shaders/dataType13.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType19.frag b/tests/glslparsertest/shaders/dataType19.frag
index cbf4bd71..f58359d1 100644
--- a/tests/glslparsertest/shaders/dataType19.frag
+++ b/tests/glslparsertest/shaders/dataType19.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType2.frag b/tests/glslparsertest/shaders/dataType2.frag
index e1df8c7c..57372be3 100644
--- a/tests/glslparsertest/shaders/dataType2.frag
+++ b/tests/glslparsertest/shaders/dataType2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType3.frag b/tests/glslparsertest/shaders/dataType3.frag
index f5c67bab..15ad92ba 100644
--- a/tests/glslparsertest/shaders/dataType3.frag
+++ b/tests/glslparsertest/shaders/dataType3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType4.frag b/tests/glslparsertest/shaders/dataType4.frag
index cc37673d..40aa3bfd 100644
--- a/tests/glslparsertest/shaders/dataType4.frag
+++ b/tests/glslparsertest/shaders/dataType4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType5.frag b/tests/glslparsertest/shaders/dataType5.frag
index 61c5a0bc..9c3d3b51 100644
--- a/tests/glslparsertest/shaders/dataType5.frag
+++ b/tests/glslparsertest/shaders/dataType5.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType6.frag b/tests/glslparsertest/shaders/dataType6.frag
index 1405cb0b..fdf08d8b 100644
--- a/tests/glslparsertest/shaders/dataType6.frag
+++ b/tests/glslparsertest/shaders/dataType6.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType7.frag b/tests/glslparsertest/shaders/dataType7.frag
index bd50582e..80f3d4ba 100644
--- a/tests/glslparsertest/shaders/dataType7.frag
+++ b/tests/glslparsertest/shaders/dataType7.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType8.frag b/tests/glslparsertest/shaders/dataType8.frag
index 4f668794..46a8e59c 100644
--- a/tests/glslparsertest/shaders/dataType8.frag
+++ b/tests/glslparsertest/shaders/dataType8.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dataType9.frag b/tests/glslparsertest/shaders/dataType9.frag
index 6e0ec7c8..112fdd17 100644
--- a/tests/glslparsertest/shaders/dataType9.frag
+++ b/tests/glslparsertest/shaders/dataType9.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dowhile.frag b/tests/glslparsertest/shaders/dowhile.frag
index f9d3258d..6beb5990 100644
--- a/tests/glslparsertest/shaders/dowhile.frag
+++ b/tests/glslparsertest/shaders/dowhile.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dvec2.frag b/tests/glslparsertest/shaders/dvec2.frag
index 3567a64e..8dc345bb 100644
--- a/tests/glslparsertest/shaders/dvec2.frag
+++ b/tests/glslparsertest/shaders/dvec2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dvec3.frag b/tests/glslparsertest/shaders/dvec3.frag
index 16bbb3d2..b5641582 100644
--- a/tests/glslparsertest/shaders/dvec3.frag
+++ b/tests/glslparsertest/shaders/dvec3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/dvec4.frag b/tests/glslparsertest/shaders/dvec4.frag
index 04e3ea4c..291eb30f 100644
--- a/tests/glslparsertest/shaders/dvec4.frag
+++ b/tests/glslparsertest/shaders/dvec4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/extension2.V110.frag b/tests/glslparsertest/shaders/extension2.V110.frag
index 7c68fd6a..f469a8b9 100644
--- a/tests/glslparsertest/shaders/extension2.V110.frag
+++ b/tests/glslparsertest/shaders/extension2.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/extension3.V110.frag b/tests/glslparsertest/shaders/extension3.V110.frag
index 30d309be..18e50b6f 100644
--- a/tests/glslparsertest/shaders/extension3.V110.frag
+++ b/tests/glslparsertest/shaders/extension3.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/extension5.V110.frag b/tests/glslparsertest/shaders/extension5.V110.frag
index d8115c9b..2b79a520 100644
--- a/tests/glslparsertest/shaders/extension5.V110.frag
+++ b/tests/glslparsertest/shaders/extension5.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/extension6.V110.frag b/tests/glslparsertest/shaders/extension6.V110.frag
index 145ce74b..b4c52765 100644
--- a/tests/glslparsertest/shaders/extension6.V110.frag
+++ b/tests/glslparsertest/shaders/extension6.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/extension7.V110.frag b/tests/glslparsertest/shaders/extension7.V110.frag
index c0943440..f5c7ad34 100644
--- a/tests/glslparsertest/shaders/extension7.V110.frag
+++ b/tests/glslparsertest/shaders/extension7.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/extension8.V110.frag b/tests/glslparsertest/shaders/extension8.V110.frag
index 614fceda..53b55f34 100644
--- a/tests/glslparsertest/shaders/extension8.V110.frag
+++ b/tests/glslparsertest/shaders/extension8.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/extension9.V110.frag b/tests/glslparsertest/shaders/extension9.V110.frag
index ad4c50ec..7ee07afb 100644
--- a/tests/glslparsertest/shaders/extension9.V110.frag
+++ b/tests/glslparsertest/shaders/extension9.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/float2.frag b/tests/glslparsertest/shaders/float2.frag
index 3a49ccc8..e040481a 100644
--- a/tests/glslparsertest/shaders/float2.frag
+++ b/tests/glslparsertest/shaders/float2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/float3.frag b/tests/glslparsertest/shaders/float3.frag
index 7b568bdc..3734af6f 100644
--- a/tests/glslparsertest/shaders/float3.frag
+++ b/tests/glslparsertest/shaders/float3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/float4.frag b/tests/glslparsertest/shaders/float4.frag
index fd6e040d..195d11d1 100644
--- a/tests/glslparsertest/shaders/float4.frag
+++ b/tests/glslparsertest/shaders/float4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/fragmentOnly.vert b/tests/glslparsertest/shaders/fragmentOnly.vert
index 2248a5af..941fe688 100644
--- a/tests/glslparsertest/shaders/fragmentOnly.vert
+++ b/tests/glslparsertest/shaders/fragmentOnly.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/fragmentOnly1.vert b/tests/glslparsertest/shaders/fragmentOnly1.vert
index b91b7cc4..4ce54891 100644
--- a/tests/glslparsertest/shaders/fragmentOnly1.vert
+++ b/tests/glslparsertest/shaders/fragmentOnly1.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/fragmentOnly2.vert b/tests/glslparsertest/shaders/fragmentOnly2.vert
index fcbd1be7..12125b7c 100644
--- a/tests/glslparsertest/shaders/fragmentOnly2.vert
+++ b/tests/glslparsertest/shaders/fragmentOnly2.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/fragmentOnly3.vert b/tests/glslparsertest/shaders/fragmentOnly3.vert
index 3cbb27f1..db31a926 100644
--- a/tests/glslparsertest/shaders/fragmentOnly3.vert
+++ b/tests/glslparsertest/shaders/fragmentOnly3.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/fragmentOnly4.vert b/tests/glslparsertest/shaders/fragmentOnly4.vert
index e847dd2b..261628eb 100644
--- a/tests/glslparsertest/shaders/fragmentOnly4.vert
+++ b/tests/glslparsertest/shaders/fragmentOnly4.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function1.frag b/tests/glslparsertest/shaders/function1.frag
index 8795b090..a3947ca2 100644
--- a/tests/glslparsertest/shaders/function1.frag
+++ b/tests/glslparsertest/shaders/function1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function10.frag b/tests/glslparsertest/shaders/function10.frag
index 5c42253b..5aef1b13 100644
--- a/tests/glslparsertest/shaders/function10.frag
+++ b/tests/glslparsertest/shaders/function10.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function2.V110.frag b/tests/glslparsertest/shaders/function2.V110.frag
index 217184fc..8e2a7de6 100644
--- a/tests/glslparsertest/shaders/function2.V110.frag
+++ b/tests/glslparsertest/shaders/function2.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function3.frag b/tests/glslparsertest/shaders/function3.frag
index 4fb7853f..e6317938 100644
--- a/tests/glslparsertest/shaders/function3.frag
+++ b/tests/glslparsertest/shaders/function3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function4.frag b/tests/glslparsertest/shaders/function4.frag
index ac4246de..f42166d5 100644
--- a/tests/glslparsertest/shaders/function4.frag
+++ b/tests/glslparsertest/shaders/function4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function5.frag b/tests/glslparsertest/shaders/function5.frag
index f7ada16d..6b81cb4e 100644
--- a/tests/glslparsertest/shaders/function5.frag
+++ b/tests/glslparsertest/shaders/function5.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function6.frag b/tests/glslparsertest/shaders/function6.frag
index 735cc539..7386b49f 100644
--- a/tests/glslparsertest/shaders/function6.frag
+++ b/tests/glslparsertest/shaders/function6.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function7.frag b/tests/glslparsertest/shaders/function7.frag
index 3993e66f..32a3844c 100644
--- a/tests/glslparsertest/shaders/function7.frag
+++ b/tests/glslparsertest/shaders/function7.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function8.frag b/tests/glslparsertest/shaders/function8.frag
index d8894800..cec8a00d 100644
--- a/tests/glslparsertest/shaders/function8.frag
+++ b/tests/glslparsertest/shaders/function8.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/function9.frag b/tests/glslparsertest/shaders/function9.frag
index d192cf6c..cb0cb32e 100644
--- a/tests/glslparsertest/shaders/function9.frag
+++ b/tests/glslparsertest/shaders/function9.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/hvec2.frag b/tests/glslparsertest/shaders/hvec2.frag
index 79c5ba79..8dfa04fc 100644
--- a/tests/glslparsertest/shaders/hvec2.frag
+++ b/tests/glslparsertest/shaders/hvec2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/hvec3.frag b/tests/glslparsertest/shaders/hvec3.frag
index eac2d606..16d7ceda 100644
--- a/tests/glslparsertest/shaders/hvec3.frag
+++ b/tests/glslparsertest/shaders/hvec3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/hvec4.frag b/tests/glslparsertest/shaders/hvec4.frag
index a202b538..efc44aad 100644
--- a/tests/glslparsertest/shaders/hvec4.frag
+++ b/tests/glslparsertest/shaders/hvec4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/identifier1.frag b/tests/glslparsertest/shaders/identifier1.frag
index 5d42ed18..a3463f68 100644
--- a/tests/glslparsertest/shaders/identifier1.frag
+++ b/tests/glslparsertest/shaders/identifier1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/identifier2.frag b/tests/glslparsertest/shaders/identifier2.frag
index 6e944e99..e9cd322b 100644
--- a/tests/glslparsertest/shaders/identifier2.frag
+++ b/tests/glslparsertest/shaders/identifier2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/identifier3.frag b/tests/glslparsertest/shaders/identifier3.frag
index 3831d856..077d127f 100644
--- a/tests/glslparsertest/shaders/identifier3.frag
+++ b/tests/glslparsertest/shaders/identifier3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/if1.frag b/tests/glslparsertest/shaders/if1.frag
index e7de64f4..25f34d90 100644
--- a/tests/glslparsertest/shaders/if1.frag
+++ b/tests/glslparsertest/shaders/if1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/if2.frag b/tests/glslparsertest/shaders/if2.frag
index cc34b716..eb10f72a 100644
--- a/tests/glslparsertest/shaders/if2.frag
+++ b/tests/glslparsertest/shaders/if2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/increment1.frag b/tests/glslparsertest/shaders/increment1.frag
index ea793da0..e15200d2 100644
--- a/tests/glslparsertest/shaders/increment1.frag
+++ b/tests/glslparsertest/shaders/increment1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/increment2.frag b/tests/glslparsertest/shaders/increment2.frag
index d5b9b62e..76850cd4 100644
--- a/tests/glslparsertest/shaders/increment2.frag
+++ b/tests/glslparsertest/shaders/increment2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/increment3.frag b/tests/glslparsertest/shaders/increment3.frag
index 7a7a48b1..d193f2b0 100644
--- a/tests/glslparsertest/shaders/increment3.frag
+++ b/tests/glslparsertest/shaders/increment3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/increment4.frag b/tests/glslparsertest/shaders/increment4.frag
index 0d0cf63d..d1b8779c 100644
--- a/tests/glslparsertest/shaders/increment4.frag
+++ b/tests/glslparsertest/shaders/increment4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/increment6.frag b/tests/glslparsertest/shaders/increment6.frag
index 1787290a..739211af 100644
--- a/tests/glslparsertest/shaders/increment6.frag
+++ b/tests/glslparsertest/shaders/increment6.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/main1.vert b/tests/glslparsertest/shaders/main1.vert
index 6559dfbd..44807aba 100644
--- a/tests/glslparsertest/shaders/main1.vert
+++ b/tests/glslparsertest/shaders/main1.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/main2.vert b/tests/glslparsertest/shaders/main2.vert
index f2361449..9eaf567c 100644
--- a/tests/glslparsertest/shaders/main2.vert
+++ b/tests/glslparsertest/shaders/main2.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/main3.vert b/tests/glslparsertest/shaders/main3.vert
index c2fdbe12..285c74cc 100644
--- a/tests/glslparsertest/shaders/main3.vert
+++ b/tests/glslparsertest/shaders/main3.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/matrix.V110.frag b/tests/glslparsertest/shaders/matrix.V110.frag
index f23ee8ff..21d27f6f 100644
--- a/tests/glslparsertest/shaders/matrix.V110.frag
+++ b/tests/glslparsertest/shaders/matrix.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/normal.vert b/tests/glslparsertest/shaders/normal.vert
index f3727cd2..9a0493af 100644
--- a/tests/glslparsertest/shaders/normal.vert
+++ b/tests/glslparsertest/shaders/normal.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser1.vert b/tests/glslparsertest/shaders/parser1.vert
index aca3e6cf..eb2b4ea3 100644
--- a/tests/glslparsertest/shaders/parser1.vert
+++ b/tests/glslparsertest/shaders/parser1.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser10.frag b/tests/glslparsertest/shaders/parser10.frag
index c4e7f717..0c143dd1 100644
--- a/tests/glslparsertest/shaders/parser10.frag
+++ b/tests/glslparsertest/shaders/parser10.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser3.frag b/tests/glslparsertest/shaders/parser3.frag
index 21d77f3e..c47ab502 100644
--- a/tests/glslparsertest/shaders/parser3.frag
+++ b/tests/glslparsertest/shaders/parser3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser4.frag b/tests/glslparsertest/shaders/parser4.frag
index d068c66b..9a297ca8 100644
--- a/tests/glslparsertest/shaders/parser4.frag
+++ b/tests/glslparsertest/shaders/parser4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser5.frag b/tests/glslparsertest/shaders/parser5.frag
index 74f04ed6..6993b2f8 100644
--- a/tests/glslparsertest/shaders/parser5.frag
+++ b/tests/glslparsertest/shaders/parser5.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser6.frag b/tests/glslparsertest/shaders/parser6.frag
index c61bb529..b8f0f37a 100644
--- a/tests/glslparsertest/shaders/parser6.frag
+++ b/tests/glslparsertest/shaders/parser6.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser7.frag b/tests/glslparsertest/shaders/parser7.frag
index affa69bd..53f960cd 100644
--- a/tests/glslparsertest/shaders/parser7.frag
+++ b/tests/glslparsertest/shaders/parser7.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser8.frag b/tests/glslparsertest/shaders/parser8.frag
index 0f590509..31ccf90a 100644
--- a/tests/glslparsertest/shaders/parser8.frag
+++ b/tests/glslparsertest/shaders/parser8.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/parser9.frag b/tests/glslparsertest/shaders/parser9.frag
index 5749e679..7101e6a0 100644
--- a/tests/glslparsertest/shaders/parser9.frag
+++ b/tests/glslparsertest/shaders/parser9.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess0.frag b/tests/glslparsertest/shaders/preprocess0.frag
index b96d8216..00ad8e28 100644
--- a/tests/glslparsertest/shaders/preprocess0.frag
+++ b/tests/glslparsertest/shaders/preprocess0.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess1.frag b/tests/glslparsertest/shaders/preprocess1.frag
index 6b56ec4b..79eead86 100644
--- a/tests/glslparsertest/shaders/preprocess1.frag
+++ b/tests/glslparsertest/shaders/preprocess1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess10.frag b/tests/glslparsertest/shaders/preprocess10.frag
index d07794be..4e98cf48 100644
--- a/tests/glslparsertest/shaders/preprocess10.frag
+++ b/tests/glslparsertest/shaders/preprocess10.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess2.frag b/tests/glslparsertest/shaders/preprocess2.frag
index 67f7c39c..515a05f8 100644
--- a/tests/glslparsertest/shaders/preprocess2.frag
+++ b/tests/glslparsertest/shaders/preprocess2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess3.frag b/tests/glslparsertest/shaders/preprocess3.frag
index 27aba749..5fcfc4b0 100644
--- a/tests/glslparsertest/shaders/preprocess3.frag
+++ b/tests/glslparsertest/shaders/preprocess3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess4.frag b/tests/glslparsertest/shaders/preprocess4.frag
index 2adc73ba..d8f1b39c 100644
--- a/tests/glslparsertest/shaders/preprocess4.frag
+++ b/tests/glslparsertest/shaders/preprocess4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess6.frag b/tests/glslparsertest/shaders/preprocess6.frag
index 15e8df64..42b7fa28 100644
--- a/tests/glslparsertest/shaders/preprocess6.frag
+++ b/tests/glslparsertest/shaders/preprocess6.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/preprocess7.frag b/tests/glslparsertest/shaders/preprocess7.frag
index 772483bd..25aae6c6 100644
--- a/tests/glslparsertest/shaders/preprocess7.frag
+++ b/tests/glslparsertest/shaders/preprocess7.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/scoping1.frag b/tests/glslparsertest/shaders/scoping1.frag
index 71b2d4dc..dd6ae933 100644
--- a/tests/glslparsertest/shaders/scoping1.frag
+++ b/tests/glslparsertest/shaders/scoping1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/scoping2.frag b/tests/glslparsertest/shaders/scoping2.frag
index 457ad664..98cd1c6e 100644
--- a/tests/glslparsertest/shaders/scoping2.frag
+++ b/tests/glslparsertest/shaders/scoping2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct1.frag b/tests/glslparsertest/shaders/struct1.frag
index 3fd65daa..f958fc86 100644
--- a/tests/glslparsertest/shaders/struct1.frag
+++ b/tests/glslparsertest/shaders/struct1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct10.frag b/tests/glslparsertest/shaders/struct10.frag
index 3fe1022d..68802d44 100644
--- a/tests/glslparsertest/shaders/struct10.frag
+++ b/tests/glslparsertest/shaders/struct10.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct11.frag b/tests/glslparsertest/shaders/struct11.frag
index 4f23e51d..e7523def 100644
--- a/tests/glslparsertest/shaders/struct11.frag
+++ b/tests/glslparsertest/shaders/struct11.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct2.frag b/tests/glslparsertest/shaders/struct2.frag
index e9804e4b..e3750048 100644
--- a/tests/glslparsertest/shaders/struct2.frag
+++ b/tests/glslparsertest/shaders/struct2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct3.frag b/tests/glslparsertest/shaders/struct3.frag
index 58e3681c..a9a7b976 100644
--- a/tests/glslparsertest/shaders/struct3.frag
+++ b/tests/glslparsertest/shaders/struct3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct4.frag b/tests/glslparsertest/shaders/struct4.frag
index b8299525..7b45ac5c 100644
--- a/tests/glslparsertest/shaders/struct4.frag
+++ b/tests/glslparsertest/shaders/struct4.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct5.frag b/tests/glslparsertest/shaders/struct5.frag
index 8614fc5c..a99277d3 100644
--- a/tests/glslparsertest/shaders/struct5.frag
+++ b/tests/glslparsertest/shaders/struct5.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct6.frag b/tests/glslparsertest/shaders/struct6.frag
index e7d1451d..d740426f 100644
--- a/tests/glslparsertest/shaders/struct6.frag
+++ b/tests/glslparsertest/shaders/struct6.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct7.frag b/tests/glslparsertest/shaders/struct7.frag
index bc820b1a..afef9e45 100644
--- a/tests/glslparsertest/shaders/struct7.frag
+++ b/tests/glslparsertest/shaders/struct7.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct8.frag b/tests/glslparsertest/shaders/struct8.frag
index 5693f7a1..f9fdf2c1 100644
--- a/tests/glslparsertest/shaders/struct8.frag
+++ b/tests/glslparsertest/shaders/struct8.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/struct9.frag b/tests/glslparsertest/shaders/struct9.frag
index 50dda46e..02534664 100644
--- a/tests/glslparsertest/shaders/struct9.frag
+++ b/tests/glslparsertest/shaders/struct9.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/swizzle1.frag b/tests/glslparsertest/shaders/swizzle1.frag
index 0a39c979..be9cbadb 100644
--- a/tests/glslparsertest/shaders/swizzle1.frag
+++ b/tests/glslparsertest/shaders/swizzle1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/swizzle2.frag b/tests/glslparsertest/shaders/swizzle2.frag
index 486fa3a6..d0a82ed3 100644
--- a/tests/glslparsertest/shaders/swizzle2.frag
+++ b/tests/glslparsertest/shaders/swizzle2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/swizzle3.frag b/tests/glslparsertest/shaders/swizzle3.frag
index 121e3f2c..1fc375a8 100644
--- a/tests/glslparsertest/shaders/swizzle3.frag
+++ b/tests/glslparsertest/shaders/swizzle3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/typecast.frag b/tests/glslparsertest/shaders/typecast.frag
index 6bec977e..cda23384 100644
--- a/tests/glslparsertest/shaders/typecast.frag
+++ b/tests/glslparsertest/shaders/typecast.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/uniform.frag b/tests/glslparsertest/shaders/uniform.frag
index 588738eb..fb9d30b2 100644
--- a/tests/glslparsertest/shaders/uniform.frag
+++ b/tests/glslparsertest/shaders/uniform.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/uniform1.frag b/tests/glslparsertest/shaders/uniform1.frag
index 93a17759..d4d17f8a 100644
--- a/tests/glslparsertest/shaders/uniform1.frag
+++ b/tests/glslparsertest/shaders/uniform1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/varying.frag b/tests/glslparsertest/shaders/varying.frag
index 57a97bed..9533008a 100644
--- a/tests/glslparsertest/shaders/varying.frag
+++ b/tests/glslparsertest/shaders/varying.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/varying1.frag b/tests/glslparsertest/shaders/varying1.frag
index bbbbab5c..100de392 100644
--- a/tests/glslparsertest/shaders/varying1.frag
+++ b/tests/glslparsertest/shaders/varying1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/varying2.frag b/tests/glslparsertest/shaders/varying2.frag
index 35cc7477..fe98fbbd 100644
--- a/tests/glslparsertest/shaders/varying2.frag
+++ b/tests/glslparsertest/shaders/varying2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/varying3.frag b/tests/glslparsertest/shaders/varying3.frag
index 0523c0a4..d7d1a9df 100644
--- a/tests/glslparsertest/shaders/varying3.frag
+++ b/tests/glslparsertest/shaders/varying3.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/vector.frag b/tests/glslparsertest/shaders/vector.frag
index 8ad8f4c2..8e3e8e33 100644
--- a/tests/glslparsertest/shaders/vector.frag
+++ b/tests/glslparsertest/shaders/vector.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/version2.V110.frag b/tests/glslparsertest/shaders/version2.V110.frag
index 6c1ba8b0..b1a92021 100644
--- a/tests/glslparsertest/shaders/version2.V110.frag
+++ b/tests/glslparsertest/shaders/version2.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/version3.V110.frag b/tests/glslparsertest/shaders/version3.V110.frag
index 8d2be0b3..8e99386e 100644
--- a/tests/glslparsertest/shaders/version3.V110.frag
+++ b/tests/glslparsertest/shaders/version3.V110.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/vertex.vert b/tests/glslparsertest/shaders/vertex.vert
index be4897fd..52e7158b 100644
--- a/tests/glslparsertest/shaders/vertex.vert
+++ b/tests/glslparsertest/shaders/vertex.vert
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/vertexOnly.frag b/tests/glslparsertest/shaders/vertexOnly.frag
index f10aecca..6459761c 100644
--- a/tests/glslparsertest/shaders/vertexOnly.frag
+++ b/tests/glslparsertest/shaders/vertexOnly.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/vertexOnly1.frag b/tests/glslparsertest/shaders/vertexOnly1.frag
index 38199726..65c138ad 100644
--- a/tests/glslparsertest/shaders/vertexOnly1.frag
+++ b/tests/glslparsertest/shaders/vertexOnly1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/vertexOnly2.frag b/tests/glslparsertest/shaders/vertexOnly2.frag
index 200c720e..a9757905 100644
--- a/tests/glslparsertest/shaders/vertexOnly2.frag
+++ b/tests/glslparsertest/shaders/vertexOnly2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/while.frag b/tests/glslparsertest/shaders/while.frag
index 92e6c572..a05d2e0f 100644
--- a/tests/glslparsertest/shaders/while.frag
+++ b/tests/glslparsertest/shaders/while.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/while1.frag b/tests/glslparsertest/shaders/while1.frag
index 73eed2b6..a3efaf44 100644
--- a/tests/glslparsertest/shaders/while1.frag
+++ b/tests/glslparsertest/shaders/while1.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/glslparsertest/shaders/while2.frag b/tests/glslparsertest/shaders/while2.frag
index 9498b450..de8ccfb4 100644
--- a/tests/glslparsertest/shaders/while2.frag
+++ b/tests/glslparsertest/shaders/while2.frag
@@ -1,6 +1,7 @@
 // [config]
 // expect_result: fail
 // glsl_version: 1.10
+// glsles_version: 1.00
 //
 // # NOTE: Config section was auto-generated from file
 // # NOTE: 'glslparser.tests' at git revision
diff --git a/tests/shaders/shader_runner.c b/tests/shaders/shader_runner.c
index 9089f09d..b8f1d0d2 100644
--- a/tests/shaders/shader_runner.c
+++ b/tests/shaders/shader_runner.c
@@ -50,6 +50,9 @@ PIGLIT_GL_TEST_CONFIG_BEGIN
 		get_required_versions(argv[1], &config);
 	else
 		config.supports_gl_compat_version = 10;
+#if defined(PIGLIT_USE_OPENGL_ES2)
+	config.supports_gl_es_version = 20;
+#endif
 
 	config.window_width = 250;
 	config.window_height = 250;
diff --git a/tests/shaders/shader_runner_gles_workarounds.h b/tests/shaders/shader_runner_gles_workarounds.h
index 2b91f635..e6f442cc 100644
--- a/tests/shaders/shader_runner_gles_workarounds.h
+++ b/tests/shaders/shader_runner_gles_workarounds.h
@@ -117,6 +117,43 @@ unsupported_function(const char *name, ...)
 #define piglit_ortho_projection(...) UNSUPPORTED_FUNCTION(piglit_ortho_projection, 0, __VA_ARGS__)
 #define piglit_compile_program(...) UNSUPPORTED_FUNCTION(piglit_compile_program, 0, __VA_ARGS__)
 
+#define glClipPlane(...) 				UNSUPPORTED_FUNCTION(glClipPlane, 0)
+#define glDisableClientState(...) 			UNSUPPORTED_FUNCTION(glDisableClientState, 0)
+#define glEnableClientState(...) 			UNSUPPORTED_FUNCTION(glEnableClientState, 0)
+#define glProgramEnvParameter4fvARB(...) 		UNSUPPORTED_FUNCTION(glProgramEnvParameter4fvARB, 0)
+#define glProgramLocalParameter4fvARB(...) 		UNSUPPORTED_FUNCTION(glProgramLocalParameter4fvARB, 0)
+#define glShadeModel(...) 				UNSUPPORTED_FUNCTION(glShadeModel, 0)
+
+#if defined(PIGLIT_USE_OPENGL_ES2)
+#define glMapBuffer(...) UNSUPPORTED_FUNCTION(glMapBuffer, 0)
+#define glUnmapBuffer(...) UNSUPPORTED_FUNCTION(glUnmapBuffer, 0)
+#define glUniform1ui(...) UNSUPPORTED_FUNCTION(glUniform1ui, 0)
+#define glUniform2uiv(...) UNSUPPORTED_FUNCTION(glUniform2uiv, 0)
+#define glUniform3uiv(...) UNSUPPORTED_FUNCTION(glUniform3uiv, 0)
+#define glUniform4uiv(...) UNSUPPORTED_FUNCTION(glUniform4uiv, 0)
+#define glUniformMatrix2x3fv(...) UNSUPPORTED_FUNCTION(glUniformMatrix2x3fv, 0)
+#define glUniformMatrix2x4fv(...) UNSUPPORTED_FUNCTION(glUniformMatrix2x4fv, 0)
+#define glUniformMatrix3x2fv(...) UNSUPPORTED_FUNCTION(glUniformMatrix3x2fv, 0)
+#define glUniformMatrix3x4fv(...) UNSUPPORTED_FUNCTION(glUniformMatrix3x4fv, 0)
+#define glUniformMatrix4x2fv(...) UNSUPPORTED_FUNCTION(glUniformMatrix4x2fv, 0)
+#define glUniformMatrix4x3fv(...) UNSUPPORTED_FUNCTION(glUniformMatrix4x3fv, 0)
+#define glDrawArraysInstanced(...) UNSUPPORTED_FUNCTION(glDrawArrayInstanced, 0)
+#define glGetActiveUniformBlockiv(...) UNSUPPORTED_FUNCTION(glGetActiveUniformBlockiv, 0)
+#define glBindBufferBase(...) UNSUPPORTED_FUNCTION(glBindBufferiBase, 0)
+#define glGetUniformIndices(...) UNSUPPORTED_FUNCTION(glGetUniformIndices, 0)
+#define glGetActiveUniformsiv(...) UNSUPPORTED_FUNCTION(glGetActiveUniformsiv, 0)
+#define glGenVertexArrays(...) UNSUPPORTED_FUNCTION(glGenVertexArrays, 0)
+#define glBindVertexArray(...) UNSUPPORTED_FUNCTION(glBindVertexArray, 0)
+#endif /* PIGLIT_USE_OPENGL_ES2 */
+
+#define glBindProgramARB(a, b) \
+	/* Custom definition to suppress unused-variable warnings. */ \
+	({ \
+	 	(void) a; \
+	 	(void) b; \
+		unsupported_function("glBindProgramARB"); \
+	 })
+
 #define glClipPlane(...) 				UNSUPPORTED_FUNCTION(glClipPlane, 0, __VA_ARGS__)
 #define glDisableClientState(...) 			UNSUPPORTED_FUNCTION(glDisableClientState, 0, __VA_ARGS__)
 #define glEnableClientState(...) 			UNSUPPORTED_FUNCTION(glEnableClientState, 0, __VA_ARGS__)
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-rd.shader_test
deleted file mode 100644
index 789fb92a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 223f27bc..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test
deleted file mode 100644
index 647cc023..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-wr.shader_test
deleted file mode 100644
index 5dd759e1..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 62dfd104..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 53d1502a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,110 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test
deleted file mode 100644
index acc3b779..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,150 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test
deleted file mode 100644
index 4e826869..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test
+++ /dev/null
@@ -1,95 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-rd.shader_test
deleted file mode 100644
index 10704c91..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 2ea3dbb3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test
deleted file mode 100644
index e4451a06..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test
+++ /dev/null
@@ -1,96 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-wr.shader_test
deleted file mode 100644
index 079fec36..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-index-wr.shader_test
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-rd.shader_test
deleted file mode 100644
index 600ec874..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-row-rd.shader_test
deleted file mode 100644
index 682426e3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-row-wr.shader_test
deleted file mode 100644
index 479a36a3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-wr.shader_test
deleted file mode 100644
index e7e17cc8..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat2-wr.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-rd.shader_test
deleted file mode 100644
index 9421fd4d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 3bda7cb8..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test
deleted file mode 100644
index b993a57b..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,120 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-wr.shader_test
deleted file mode 100644
index 9933f364..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index cb5b4f7d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 33a26f0d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,188 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test
deleted file mode 100644
index 6d5cb6a9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,273 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test
deleted file mode 100644
index 5fe13658..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test
+++ /dev/null
@@ -1,119 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-rd.shader_test
deleted file mode 100644
index b42f5676..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index 1f004920..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test
deleted file mode 100644
index d9d5a9ba..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test
+++ /dev/null
@@ -1,120 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-wr.shader_test
deleted file mode 100644
index 3f8df00e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-index-wr.shader_test
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-rd.shader_test
deleted file mode 100644
index 672a4962..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-row-rd.shader_test
deleted file mode 100644
index 710fcdbf..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-row-wr.shader_test
deleted file mode 100644
index b42d6561..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-wr.shader_test
deleted file mode 100644
index d95a370c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat3-wr.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-rd.shader_test
deleted file mode 100644
index 4d2b5589..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 52799654..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,123 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test
deleted file mode 100644
index b2c5fec1..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,177 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-wr.shader_test
deleted file mode 100644
index c5dbafac..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index 411370ce..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,102 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index 839422f3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,296 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test
deleted file mode 100644
index e3be0477..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,444 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test
deleted file mode 100644
index 7cd95155..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test
+++ /dev/null
@@ -1,143 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-rd.shader_test
deleted file mode 100644
index 52a62a9f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 681215df..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,102 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test
deleted file mode 100644
index 4eb49bc9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test
+++ /dev/null
@@ -1,144 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-wr.shader_test
deleted file mode 100644
index 58c90cc5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-index-wr.shader_test
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-rd.shader_test
deleted file mode 100644
index 2994055d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-row-rd.shader_test
deleted file mode 100644
index 85f4a154..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-row-wr.shader_test
deleted file mode 100644
index aa7ba8dc..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,77 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-wr.shader_test
deleted file mode 100644
index df4529ae..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-array-mat4-wr.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-rd.shader_test
deleted file mode 100644
index 2520a0d6..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,44 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-row-rd.shader_test
deleted file mode 100644
index ff170a6e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-row-wr.shader_test
deleted file mode 100644
index 28a79b02..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,71 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-wr.shader_test
deleted file mode 100644
index 76003d12..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-rd.shader_test
deleted file mode 100644
index a74c2bf8..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-row-rd.shader_test
deleted file mode 100644
index 1ca63143..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,44 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-row-wr.shader_test
deleted file mode 100644
index f06d180e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-wr.shader_test
deleted file mode 100644
index abfc94a2..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat2-wr.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-rd.shader_test
deleted file mode 100644
index 58ba94a1..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,49 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-row-rd.shader_test
deleted file mode 100644
index 4815ec89..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,84 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-row-wr.shader_test
deleted file mode 100644
index a4e33ed8..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,112 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-wr.shader_test
deleted file mode 100644
index 93e9235b..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-rd.shader_test
deleted file mode 100644
index a7d108bf..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-row-rd.shader_test
deleted file mode 100644
index a6226080..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,49 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-row-wr.shader_test
deleted file mode 100644
index 53e27497..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-wr.shader_test
deleted file mode 100644
index 557a342a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat3-wr.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-rd.shader_test
deleted file mode 100644
index 7db671eb..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-row-rd.shader_test
deleted file mode 100644
index 9e838a81..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,120 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-row-wr.shader_test
deleted file mode 100644
index 7f22a2d5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,169 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-wr.shader_test
deleted file mode 100644
index 2f67f864..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-rd.shader_test
deleted file mode 100644
index b8c807f7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-row-rd.shader_test
deleted file mode 100644
index 3849da4f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-row-wr.shader_test
deleted file mode 100644
index 61b76e95..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-wr.shader_test
deleted file mode 100644
index 8965d15a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-temp-mat4-wr.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test
deleted file mode 100644
index d640d667..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index eff7102c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index e4a33a42..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,78 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index baf1124c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,116 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test
deleted file mode 100644
index 54993272..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 79c6d746..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,78 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-rd.shader_test
deleted file mode 100644
index 900a3f3b..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test
deleted file mode 100644
index eabf8735..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test
deleted file mode 100644
index b1666643..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 3c8dd098..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,86 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index 3083001d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,93 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index f7783a9e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,194 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test
deleted file mode 100644
index 227a83eb..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index 1d88b465..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,93 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-rd.shader_test
deleted file mode 100644
index 971aa6e2..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test
deleted file mode 100644
index 20669fa0..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test
deleted file mode 100644
index 1d361388..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 1cc15868..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,122 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index cb7401fc..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,108 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index f6d5d39f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,302 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test
deleted file mode 100644
index 859952fd..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 55c396d9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,108 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-rd.shader_test
deleted file mode 100644
index 715cc2a4..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test
deleted file mode 100644
index 72d5efcf..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-col-rd.shader_test
deleted file mode 100644
index b804dd82..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test
deleted file mode 100644
index 140b00c8..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,59 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-rd.shader_test
deleted file mode 100644
index d55ef3ac..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-row-rd.shader_test
deleted file mode 100644
index eac0f52e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-col-rd.shader_test
deleted file mode 100644
index 19e36e18..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test
deleted file mode 100644
index abe09dae..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,85 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-rd.shader_test
deleted file mode 100644
index a96acf78..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-row-rd.shader_test
deleted file mode 100644
index 4e8d3e60..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-col-rd.shader_test
deleted file mode 100644
index 3986b557..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test
deleted file mode 100644
index 9212cd89..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-rd.shader_test
deleted file mode 100644
index 4b6c013c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-row-rd.shader_test
deleted file mode 100644
index d858ca54..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-uniform-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-col-rd.shader_test
deleted file mode 100644
index 8198236a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 6b9c7888..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index af2551a7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 213cb989..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,111 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-rd.shader_test
deleted file mode 100644
index 412417c3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 9c302026..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-rd.shader_test
deleted file mode 100644
index d736018c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-row-rd.shader_test
deleted file mode 100644
index 852e1b19..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-col-rd.shader_test
deleted file mode 100644
index 929a47e3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 595069d7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index ac3d15ab..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 905eaf90..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,189 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-rd.shader_test
deleted file mode 100644
index fabf1a56..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index ee8b6d22..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-rd.shader_test
deleted file mode 100644
index c60d5d4d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-row-rd.shader_test
deleted file mode 100644
index dfda10e9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-col-rd.shader_test
deleted file mode 100644
index 65febbab..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index dae0367b..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index cbb486ce..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index ab6060b5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,297 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-rd.shader_test
deleted file mode 100644
index 6080b812..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 14350290..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-rd.shader_test
deleted file mode 100644
index 2adf4aba..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-row-rd.shader_test
deleted file mode 100644
index b8261c48..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-col-rd.shader_test
deleted file mode 100644
index 4e5db323..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-col-row-rd.shader_test
deleted file mode 100644
index 86f05f15..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-rd.shader_test
deleted file mode 100644
index dc7f48d5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-row-rd.shader_test
deleted file mode 100644
index 4b37fa01..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-col-rd.shader_test
deleted file mode 100644
index 208ac1e8..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-col-row-rd.shader_test
deleted file mode 100644
index 7bc78f9e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,86 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-rd.shader_test
deleted file mode 100644
index 4967d6ca..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-row-rd.shader_test
deleted file mode 100644
index 3f3733bc..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-col-rd.shader_test
deleted file mode 100644
index 8883caec..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-col-row-rd.shader_test
deleted file mode 100644
index 9085f16f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,122 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-rd.shader_test
deleted file mode 100644
index 6de6338a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-row-rd.shader_test
deleted file mode 100644
index 00c872a0..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/fs-varying-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-rd.shader_test
deleted file mode 100644
index f2ef2b97..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 6696fd34..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test
deleted file mode 100644
index 924807d6..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,83 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-wr.shader_test
deleted file mode 100644
index 4bb04e81..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index aeede582..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 7f2ce85a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,111 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test
deleted file mode 100644
index adaf608f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,154 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test
deleted file mode 100644
index 39c6dff2..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test
+++ /dev/null
@@ -1,99 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-rd.shader_test
deleted file mode 100644
index 7ee9bdac..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index dedcbdea..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test
deleted file mode 100644
index e5a5c084..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test
+++ /dev/null
@@ -1,100 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-wr.shader_test
deleted file mode 100644
index 2ade3d1a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-index-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-rd.shader_test
deleted file mode 100644
index 427693fe..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-row-rd.shader_test
deleted file mode 100644
index 449d3245..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m[3];
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-row-wr.shader_test
deleted file mode 100644
index e20cf7db..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-wr.shader_test
deleted file mode 100644
index 3d4e2ff6..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat2-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix[3];
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-rd.shader_test
deleted file mode 100644
index 36a79a25..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 1a6df3d0..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test
deleted file mode 100644
index 5c5a2f77..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-wr.shader_test
deleted file mode 100644
index 743d6f40..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index e12ff327..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 79376ab1..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,189 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test
deleted file mode 100644
index 63c18e81..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,277 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test
deleted file mode 100644
index 4a2ca89c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test
+++ /dev/null
@@ -1,123 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-rd.shader_test
deleted file mode 100644
index 6c106dde..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index 738ee806..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test
deleted file mode 100644
index def99ade..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-wr.shader_test
deleted file mode 100644
index b7dd57d3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-index-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-rd.shader_test
deleted file mode 100644
index 2ffe44a0..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-row-rd.shader_test
deleted file mode 100644
index c479f2eb..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m[3];
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-row-wr.shader_test
deleted file mode 100644
index 1d19e560..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-wr.shader_test
deleted file mode 100644
index f34b68b6..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat3-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix[3];
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-rd.shader_test
deleted file mode 100644
index b99a9f4a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index d10168b8..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test
deleted file mode 100644
index 66552664..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,181 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-wr.shader_test
deleted file mode 100644
index 05b0d194..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,80 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index 986d54c9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index 993f754c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,297 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test
deleted file mode 100644
index 1bec9c9d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,448 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test
deleted file mode 100644
index d411fe0d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test
+++ /dev/null
@@ -1,147 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-rd.shader_test
deleted file mode 100644
index ec32a063..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 71d30b0c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test
deleted file mode 100644
index 8785feaf..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test
+++ /dev/null
@@ -1,148 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-wr.shader_test
deleted file mode 100644
index 63d23291..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-index-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-rd.shader_test
deleted file mode 100644
index 73317b31..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-row-rd.shader_test
deleted file mode 100644
index 9a917dad..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m[3];
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-row-wr.shader_test
deleted file mode 100644
index 5225449c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-wr.shader_test
deleted file mode 100644
index 0e8d4fd5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-array-mat4-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix[3];
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-rd.shader_test
deleted file mode 100644
index f2c91e5e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-row-rd.shader_test
deleted file mode 100644
index ce798073..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,59 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-row-wr.shader_test
deleted file mode 100644
index 2514a0d7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,75 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-wr.shader_test
deleted file mode 100644
index 87430fb5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-rd.shader_test
deleted file mode 100644
index ab121dbe..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-row-rd.shader_test
deleted file mode 100644
index 2e4206c6..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 m = mat2(1.0, 2.0, 3.0, 4.0);
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-row-wr.shader_test
deleted file mode 100644
index 838e68eb..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-wr.shader_test
deleted file mode 100644
index f601edc1..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat2-wr.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-rd.shader_test
deleted file mode 100644
index f5ad796c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-row-rd.shader_test
deleted file mode 100644
index 069e68b5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,85 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-row-wr.shader_test
deleted file mode 100644
index 6236a29e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,116 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-wr.shader_test
deleted file mode 100644
index 2d627741..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-rd.shader_test
deleted file mode 100644
index 7c3b650f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-row-rd.shader_test
deleted file mode 100644
index 30c7a54d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-row-wr.shader_test
deleted file mode 100644
index 1fa3d11e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-wr.shader_test
deleted file mode 100644
index ed09640e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat3-wr.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-rd.shader_test
deleted file mode 100644
index 608edfe9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-row-rd.shader_test
deleted file mode 100644
index 70985b6d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-row-wr.shader_test
deleted file mode 100644
index 4c35716d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,173 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-wr.shader_test
deleted file mode 100644
index db671c9a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-rd.shader_test
deleted file mode 100644
index c8d2908c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-row-rd.shader_test
deleted file mode 100644
index cacfeca5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-row-wr.shader_test
deleted file mode 100644
index e6d9e3f2..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-wr.shader_test
deleted file mode 100644
index 3fae51ef..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-temp-mat4-wr.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 110
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test
deleted file mode 100644
index 6f4aba50..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 1ab8c668..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 99f70a1e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 192b9510..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,117 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test
deleted file mode 100644
index b9e2d87c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,59 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 0b59f773..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform mat2x2 m[2] 9.0 10.0 11.0 12.0
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-rd.shader_test
deleted file mode 100644
index fe004293..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test
deleted file mode 100644
index 04684dae..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m[0] 1.0 2.0 3.0 4.0
-uniform mat2x2 m[1] 5.0 6.0 7.0 8.0
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test
deleted file mode 100644
index 8fce20df..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 28fe4970..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index 506b9d40..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,94 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 0489e594..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,195 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test
deleted file mode 100644
index 3f6aacca..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,59 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index 595f9c99..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,94 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform mat3x3 m[2] 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-rd.shader_test
deleted file mode 100644
index 6ec1c983..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test
deleted file mode 100644
index 4bb8ac40..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform mat3x3 m[1] 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test
deleted file mode 100644
index afdaba1b..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 7576be19..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,123 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index f2100013..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,109 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index ab7f16da..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,303 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test
deleted file mode 100644
index c78f738f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,59 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 2341e881..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,109 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform mat4x4 m[2] 33.0 34.0 35.0 36.0 37.0 38.0 39.0 40.0 41.0 42.0 43.0 44.0 45.0 46.0 47.0 48.0
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-rd.shader_test
deleted file mode 100644
index 9989782e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test
deleted file mode 100644
index 4bf92f36..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m[0] 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform mat4x4 m[1] 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-col-rd.shader_test
deleted file mode 100644
index a9dd5c18..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test
deleted file mode 100644
index 5b24098f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-rd.shader_test
deleted file mode 100644
index 3fd7a80f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-row-rd.shader_test
deleted file mode 100644
index 8c1ad98f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat2x2 m 1.0 2.0 3.0 4.0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-col-rd.shader_test
deleted file mode 100644
index 8954fd20..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test
deleted file mode 100644
index ab3e3573..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,86 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-rd.shader_test
deleted file mode 100644
index ffb90840..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-row-rd.shader_test
deleted file mode 100644
index de843da9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat3x3 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-col-rd.shader_test
deleted file mode 100644
index cc9a6a7c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test
deleted file mode 100644
index 8581ec35..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,122 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-rd.shader_test
deleted file mode 100644
index 33cad921..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-row-rd.shader_test
deleted file mode 100644
index a5f35082..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-uniform-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform mat4x4 m 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-rd.shader_test
deleted file mode 100644
index 188f437d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index f3ea08c1..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,78 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test
deleted file mode 100644
index adaf9304..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,93 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-wr.shader_test
deleted file mode 100644
index 18d5e150..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 1943a822..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,89 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 0c963c7f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,127 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test
deleted file mode 100644
index 25400fa3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,164 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test
deleted file mode 100644
index 2e8e07af..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test
+++ /dev/null
@@ -1,108 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-rd.shader_test
deleted file mode 100644
index 6ae95e26..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 1eccd812..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,89 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test
deleted file mode 100644
index 920148ec..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test
+++ /dev/null
@@ -1,110 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-wr.shader_test
deleted file mode 100644
index 92a80843..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-index-wr.shader_test
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-rd.shader_test
deleted file mode 100644
index 3444392f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-row-rd.shader_test
deleted file mode 100644
index 59771c3c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-row-wr.shader_test
deleted file mode 100644
index ef202b0f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,75 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-wr.shader_test
deleted file mode 100644
index c543a61f..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat2-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat2(0.0);
-    dst_matrix[1] = mat2(0.0);
-    dst_matrix[2] = mat2(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-rd.shader_test
deleted file mode 100644
index d8f16c07..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index b46a6b71..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,104 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test
deleted file mode 100644
index 544a7294..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,134 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-wr.shader_test
deleted file mode 100644
index eec0614b..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index 348185dd..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,104 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 3b681d41..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,205 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test
deleted file mode 100644
index 7f0ef4f7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,287 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test
deleted file mode 100644
index 7665967a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test
+++ /dev/null
@@ -1,132 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-rd.shader_test
deleted file mode 100644
index 0d3841d0..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index 38608541..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,104 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test
deleted file mode 100644
index be8f11e2..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test
+++ /dev/null
@@ -1,134 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-wr.shader_test
deleted file mode 100644
index 99747c26..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-index-wr.shader_test
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-rd.shader_test
deleted file mode 100644
index 3ec6d40e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-row-rd.shader_test
deleted file mode 100644
index 07a131a6..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-row-wr.shader_test
deleted file mode 100644
index 81fdac43..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,83 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-wr.shader_test
deleted file mode 100644
index f156001c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat3-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat3(0.0);
-    dst_matrix[1] = mat3(0.0);
-    dst_matrix[2] = mat3(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-rd.shader_test
deleted file mode 100644
index 7fa1b6a5..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index fdb2f317..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,140 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test
deleted file mode 100644
index c74b56a0..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,191 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-wr.shader_test
deleted file mode 100644
index 98a69b55..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,89 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index 7febdad7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,119 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index 11bf4fc6..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,313 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test
deleted file mode 100644
index bf1a8377..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,458 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test
deleted file mode 100644
index d7296dc7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test
+++ /dev/null
@@ -1,156 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-rd.shader_test
deleted file mode 100644
index 70d36d69..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index a1501744..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,119 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test
deleted file mode 100644
index 7b9064c0..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test
+++ /dev/null
@@ -1,158 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-wr.shader_test
deleted file mode 100644
index 85d170a3..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-index-wr.shader_test
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-rd.shader_test
deleted file mode 100644
index 806f6973..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-row-rd.shader_test
deleted file mode 100644
index 74a0a39d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4 m[3];
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-row-wr.shader_test
deleted file mode 100644
index c858011c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,91 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-wr.shader_test
deleted file mode 100644
index 53487ac1..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-array-mat4-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix[0] = mat4(0.0);
-    dst_matrix[1] = mat4(0.0);
-    dst_matrix[2] = mat4(0.0);
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix[3];
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-rd.shader_test
deleted file mode 100644
index 9b815555..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-row-rd.shader_test
deleted file mode 100644
index a58e119e..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-row-wr.shader_test
deleted file mode 100644
index e588165d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,84 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-wr.shader_test
deleted file mode 100644
index 2ba1a267..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-rd.shader_test
deleted file mode 100644
index 31fbc1f7..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-row-rd.shader_test
deleted file mode 100644
index 1552fc78..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-row-wr.shader_test
deleted file mode 100644
index 2a209bb9..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,66 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-wr.shader_test
deleted file mode 100644
index 71f3f5a4..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat2-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-}
-
-[fragment shader]
-uniform mat2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-rd.shader_test
deleted file mode 100644
index d7020a52..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,67 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-row-rd.shader_test
deleted file mode 100644
index 525b1646..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,102 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-row-wr.shader_test
deleted file mode 100644
index ac262360..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,125 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-wr.shader_test
deleted file mode 100644
index 658a28ae..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-rd.shader_test
deleted file mode 100644
index 433d4d93..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-row-rd.shader_test
deleted file mode 100644
index fdfff453..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,67 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-row-wr.shader_test
deleted file mode 100644
index 723578b4..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-wr.shader_test
deleted file mode 100644
index 0b1ad044..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat3-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-}
-
-[fragment shader]
-uniform mat3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-rd.shader_test
deleted file mode 100644
index 08529d1d..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-row-rd.shader_test
deleted file mode 100644
index 17080f87..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,138 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-row-wr.shader_test
deleted file mode 100644
index e2f3d7fe..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,182 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-wr.shader_test
deleted file mode 100644
index 4b8a3065..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,80 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-rd.shader_test
deleted file mode 100644
index 8201566c..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-row-rd.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-row-rd.shader_test
deleted file mode 100644
index b15ab100..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-row-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-row-wr.shader_test
deleted file mode 100644
index 0c4083da..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,82 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-wr.shader_test b/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-wr.shader_test
deleted file mode 100644
index 0c1d478a..00000000
--- a/tests/spec/glsl-1.10/execution/variable-indexing/vs-varying-mat4-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.10
-
-[require]
-GLSL >= 1.10
-
-[vertex shader]
-#version 110
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-}
-
-[fragment shader]
-uniform mat4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.10/variable-index-read.sh b/tests/spec/glsl-1.10/variable-index-read.sh
deleted file mode 100755
index 80cb078d..00000000
--- a/tests/spec/glsl-1.10/variable-index-read.sh
+++ /dev/null
@@ -1,481 +0,0 @@
-#!/bin/bash
-
-# Generate a set of data for a sized matrix.  Elements start with a specified
-# value and increment by 1.0 for each element.
-function matrix_data
-{
-    first=$1
-    dim=$2
-
-    last=$(($first + $dim * $dim - 1))
-    seq $first $last | tr '\n' ' ' | sed 's/ /.0, /g;s/, $//;s/ *$//g'
-}
-
-
-function emit_matrix_array_initializer
-{
-    matrix_dim=$1
-    array_dim=$2
-    base_type=$3
-    indent=$4
-
-    for c in $(seq $array_dim); do
-	if [ $c -ne 1 ]; then
-	    echo ","
-	fi
-
-	first=$(((c - 1) * matrix_dim * matrix_dim + 1))
-	echo -n "${indent}    ${base_type}("
-	matrix_data $first $matrix_dim
-	echo -n ")"
-    done
-
-}
-
-
-# Emit global variable declarations for either the vertex shader or the
-# fragment shader.
-function emit_globals
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col=$5
-    expect_type=$6
-
-    v=${version/./}
-    if [ $v -ge 120 ]; then
-	base_type="mat${matrix_dim}x${matrix_dim}"
-    else
-	base_type="mat${matrix_dim}"
-    fi
-
-    type=$base_type
-    dim=""
-    if [ $array_dim -ne 0 ]; then
-	if [ $v -ge 120 ]; then
-	    type="${type}[$array_dim]"
-	else
-	    dim="[${array_dim}]"
-	fi
-    fi
-
-    if [ $array_dim -ne 0 -a "x$index_value" = "xindex" ]; then
-	echo "uniform int index;"
-    fi
-
-    if [ "x$col" = "xcol" ]; then
-	echo "uniform int col;"
-    fi
-
-    if [ "x$expect_type" == "xfloat" ]; then
-	echo "uniform int row;"
-    fi
-
-    echo "uniform ${expect_type} expect;"
-
-    if [ $v -ge 120 -a "x$mode" = "xuniform" ]; then
-	if [ $array_dim -eq 0 ]; then
-            echo -n "${mode} ${type} m = ${type}("
-	    matrix_data 1 $matrix_dim
-	    echo ");"
-	else
-	    echo "${mode} ${type} m${dim} = ${type}("
-	    emit_matrix_array_initializer $matrix_dim $array_dim $base_type ""
-	    echo ");"
-	fi
-    elif [ "x$mode" != "xtemp" ]; then
-        echo "${mode} ${type} m${dim};"
-    fi
-    echo "varying vec4 color;"
-    echo
-}
-
-
-function emit_set_matrix
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-
-    v=${version/./}
-    if [ $v -ge 120 ]; then
-	base_type="mat${matrix_dim}x${matrix_dim}"
-    else
-	base_type="mat${matrix_dim}"
-    fi
-
-    type=$base_type
-    dim=""
-    if [ $array_dim -ne 0 ]; then
-	if [ $v -ge 120 ]; then
-	    type="${type}[$array_dim]"
-	else
-	    dim="[${array_dim}]"
-	fi
-    fi
-
-    if [ $array_dim -ne 0 ]; then
-	if [ "x$mode" = "xtemp" ]; then
-	    if [ $v -ge 120 ]; then
-		echo "    ${type} m${dim} = ${type}("
-		emit_matrix_array_initializer $matrix_dim $array_dim $base_type "    "
-		echo ");"
-	    else
-		echo "    ${type} m${dim};"
-	    fi
-	fi
-
-	if [ $v -lt 120 -o "x$mode" = "xvarying" ]; then
-	    for i in $(seq 0 $(($array_dim - 1))); do
-		first=$((1 + $i * $matrix_dim * $matrix_dim))
-		echo -n "    m[$i] = mat${matrix_dim}("
-		matrix_data $first $matrix_dim
-		echo ");"
-	    done
-	fi
-    else
-	matrix_values=$(matrix_data 1 $matrix_dim)
-
-	if [ "x$mode" = "xtemp" ] ; then
-	    echo "    ${type} m = ${type}(${matrix_values});"
-	else
-	    echo "    m = ${type}(${matrix_values});"
-	fi
-    fi
-}
-
-
-function emit_vs
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col=$5
-    expect_type=$6
-    do_compare=$7
-
-    if [ $array_dim -ne 0 ]; then
-	idx="[${index_value}]"
-    else
-	idx=""
-    fi
-
-    echo "[vertex shader]"
-    emit_globals $*
-
-    echo "void main()"
-    echo "{"
-    echo "    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
-
-    # Only emit the code to set the matrix if the vertex shader is generating
-    # varyings for a fragment shader or the matrix is in local storage and the
-    # vertex shader is doing the comparison.
-    if [ "x$mode" = "xvarying" -o \( "x$mode" = "xtemp" -a  $do_compare -ne 0 \) ]; then
-	echo
-	emit_set_matrix $matrix_dim $array_dim $mode
-    fi
-
-    if [ $do_compare -ne 0 ]; then
-        # Many people thing that a vertex shader cannot read a varying.  Quote
-        # some bits from the GLSL spec so that people won't get the wrong idea
-        # when reading the test.
-	if [ "x$mode" = "xvarying" ]; then
-	    cat <<EOF
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-EOF
-	fi
-
-	if [ "x$expect_type" = "xfloat" ]; then
-	    echo "    color = (m${idx}[$col][row] == expect)"
-	else
-	    echo "    color = (m${idx}[$col] == expect)"
-	fi
-	echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
-    fi
-    echo -e "}\n"
-}
-
-
-emit_fs()
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col=$5
-    expect_type=$6
-    do_compare=$7
-
-    echo "[fragment shader]"
-    emit_globals $*
-
-    echo "void main()"
-    echo "{"
-
-    if [ $do_compare -eq 0 -a "x$mode" = "xvarying" ]; then
-	cat <<EOF
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-EOF
-    fi
-
-    if [ $do_compare -ne 0 -o "x$mode" = "xvarying" ]; then
-	if [ "x$mode" = "xtemp" ]; then
-	    emit_set_matrix $matrix_dim $array_dim $mode
-	    echo
-	fi
-
-	if [ $array_dim -ne 0 ]; then
-	    idx="[$index_value]"
-	else
-	    idx=""
-	fi
-
-	if [ "x$expect_type" = "xfloat" ]; then
-	    row="[row]"
-	else
-	    row=""
-	fi
-
-	echo "    gl_FragColor = (m${idx}[${col}]${row} == expect)"
-
-	if [ $do_compare -eq 0 ]; then
-            echo "        ? color : vec4(1.0, 0.0, 0.0, 1.0);"
-	else
-            echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
-	fi
-    else
-	echo "    gl_FragColor = color;"
-    fi
-
-    echo "}"
-    echo
-}
-
-
-function emit_test_vectors
-{
-    matrix_dim=$1
-    local array_dim=$2
-    mode=$3
-    index_value=$4
-    col=$5
-    expect_type=$6
-
-    # Optimizing GLSL linkers may reduce the size of the uniform array if tail
-    # elements are not accessed.  Shader runner will fail the test if one of
-    # the set uniforms doesn't have a location.
-    if [ "x$mode" = "xuniform" -a $v -le 110 -a $array_dim -ne 0 -a "x$index_value" != "xindex" ]; then
-	array_dim=$((index_value+1))
-    fi
-
-    cat <<EOF
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-EOF
-
-    # NOTE: shader_runner uses the matCxR names even for GLSL 1.10
-    v=${version/./}
-    type="mat${matrix_dim}x${matrix_dim}"
-    if [ "x$mode" = "xuniform" -a $v -le 110 ]; then
-	if [ $array_dim -eq 0 ]; then
-	    echo -n "uniform ${type} m "
-	    matrix_data 1 $matrix_dim | sed 's/,//g'
-	    echo
-	fi
-    fi
-
-    if [ $array_dim -eq 0 ]; then
-	sizes="1"
-    elif [ "x$index_value" = "xindex" ]; then
-	sizes=$(seq $array_dim)
-    else
-	sizes="2"
-    fi
-
-    if [ "x$col" = "xcol" ]; then
-	columns=$(seq $matrix_dim)
-    else
-	columns=2
-    fi
-
-    if [ "x$expect_type" = "xfloat" ]; then
-	rows=$(seq $matrix_dim)
-    else
-	rows=1
-    fi
-
-    for i in $sizes; do
-	if [ "x$mode" = "xuniform" -a $v -le 110 ]; then
-	    if [ $array_dim -ne 0 ]; then
-		for c in $(seq 0 $(($array_dim - 1))); do
-		    first=$((1 + c * matrix_dim * matrix_dim))
-		    echo -n "uniform ${type} m[$c] "
-		    matrix_data $first $matrix_dim | sed 's/,//g'
-		    echo
-		done
-	    fi
-	fi
-
-	if [ $array_dim -ne 0 -a "x$index_value" = "xindex" ]; then
-	    echo "uniform int index $((i - 1))"
-	fi
-
-	x_base=$(((i - 1) * (15 * matrix_dim + 10)))
-	for c in $columns; do
-	    if [ "x$col" = "xcol" ]; then
-		echo "uniform int col $((c - 1))"
-	    fi
-
-	    for r in $rows; do
-		expect=$(((i - 1) * (matrix_dim * matrix_dim) + (c - 1) * matrix_dim + r))
-		if [ "x$expect_type" = "xfloat" ]; then
-		    echo "uniform int row $((r - 1))"
-		    echo "uniform float expect $expect"
-		else
-		    e=$(seq $expect $((expect + matrix_dim - 1)) | tr '\n' ' ' | sed 's/[[:space:]]*$//g')
-		    echo "uniform ${expect_type} expect $e"
-		fi
-
-		x=$((x_base + 15 * c - 10))
-		y=$((15 * r - 10))
-		echo "draw rect $x $y 10 10"
-
-		x=$((x + 5))
-		y=$((y + 5))
-		echo "probe rgb $x $y 0.0 1.0 0.0"
-		echo
-	    done
-	done
-    done
-}
-
-# Generate a test that read from an (array of) matrix using a non-constant
-# index in the fragment shader.
-function emit_fs_rd_test
-{
-    echo "# Test generated by:"
-    echo "# ${cmd}"
-    echo
-    echo "[require]"
-    echo "GLSL >= $version"
-    echo
-
-    emit_vs $* 0
-    emit_fs $* 1
-
-    emit_test_vectors $*
-}
-
-
-# Generate a test that read from an (array of) matrix using a non-constant
-# index in the fragment shader.
-function emit_vs_rd_test
-{
-    echo "# Test generated by:"
-    echo "# ${cmd}"
-    echo
-    echo "[require]"
-    echo "GLSL >= $version"
-    echo
-
-    emit_vs $* 1
-    emit_fs $* 0
-
-    emit_test_vectors $*
-}
-
-cmd="$0 $*"
-
-if [ "x$1" = "x" ]; then
-    version="1.10"
-else
-    case "$1" in
-	1.[12]0) version="$1";;
-	*)
-	    echo "Bogus GLSL version \"$1\" specified."
-	    exit 1
-	    ;;
-    esac
-fi
-
-for mode in temp uniform varying; do
-    # More than 3 is unlikely to work for the varying tests due to using too
-    # many varying vectors.  mat4[3] uses 12 varying vectors by itself.
-    for array_dim in 0 3; do
-	for matrix_dim in 2 3 4; do
-	    if [ $array_dim -ne 0 ]; then
-		arr="array-"
-		idx_txt="index-"
-
-		emit_fs_rd_test $matrix_dim $array_dim $mode 1 col float \
-		    > fs-${mode}-${arr}mat${matrix_dim}-col-row-rd.shader_test
-
-		emit_fs_rd_test $matrix_dim $array_dim $mode 1 1   float \
-		    > fs-${mode}-${arr}mat${matrix_dim}-row-rd.shader_test
-
-		emit_fs_rd_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
-		    > fs-${mode}-${arr}mat${matrix_dim}-col-rd.shader_test
-
-		emit_fs_rd_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
-		    > fs-${mode}-${arr}mat${matrix_dim}-rd.shader_test
-
-		emit_vs_rd_test $matrix_dim $array_dim $mode 1 col float \
-		    > vs-${mode}-${arr}mat${matrix_dim}-col-row-rd.shader_test
-
-		emit_vs_rd_test $matrix_dim $array_dim $mode 1 1   float \
-		    > vs-${mode}-${arr}mat${matrix_dim}-row-rd.shader_test
-
-		emit_vs_rd_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
-		    > vs-${mode}-${arr}mat${matrix_dim}-col-rd.shader_test
-
-		emit_vs_rd_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
-		    > vs-${mode}-${arr}mat${matrix_dim}-rd.shader_test
-	    else
-		arr=""
-		idx_txt=""
-	    fi
-
-	    emit_fs_rd_test $matrix_dim $array_dim $mode index col float \
-		> fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-rd.shader_test
-
-	    emit_fs_rd_test $matrix_dim $array_dim $mode index 1   float \
-		> fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-rd.shader_test
-
-	    emit_fs_rd_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
-		> fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-rd.shader_test
-
-	    emit_fs_rd_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
-		> fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}rd.shader_test
-
-	    emit_vs_rd_test $matrix_dim $array_dim $mode index col float \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-rd.shader_test
-
-	    emit_vs_rd_test $matrix_dim $array_dim $mode index 1   float \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-rd.shader_test
-
-	    emit_vs_rd_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-rd.shader_test
-
-	    emit_vs_rd_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}rd.shader_test
-	done
-    done
-done
diff --git a/tests/spec/glsl-1.10/variable-index-write.sh b/tests/spec/glsl-1.10/variable-index-write.sh
deleted file mode 100755
index 96a47918..00000000
--- a/tests/spec/glsl-1.10/variable-index-write.sh
+++ /dev/null
@@ -1,467 +0,0 @@
-#!/bin/bash
-
-# Emit global variable declarations for either the vertex shader or the
-# fragment shader.
-function emit_globals
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col="[$5]"
-    value_type=$6
-
-    v=${version/./}
-    if [ $v -ge 120 ]; then
-	base_type="mat${matrix_dim}x${matrix_dim}"
-    else
-	base_type="mat${matrix_dim}"
-    fi
-
-    type=$base_type
-    dim=""
-    if [ $array_dim -ne 0 ]; then
-	if [ $v -ge 120 ]; then
-	    type="${type}[$array_dim]"
-	else
-	    dim="[${array_dim}]"
-	fi
-    fi
-
-    echo "uniform ${base_type} src_matrix;"
-    echo "uniform vec${matrix_dim} v;"
-    echo "uniform vec${matrix_dim} expect;"
-
-    if [ $array_dim -ne 0 ]; then
-	echo "uniform int index;"
-    fi
-
-    if [ "x$value_type" = "xfloat" ]; then
-	echo "uniform int row;"
-    fi
-
-    echo "uniform int col;"
-    echo "uniform ${value_type} value;"
-
-    if [ "x$mode" = "xvarying" ]; then
-	echo "varying ${type} dst_matrix${dim};"
-    fi
-    echo
-}
-
-
-function emit_set_matrix
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col="[$5]"
-    value_type=$6
-
-    v=${version/./}
-    if [ $v -ge 120 ]; then
-	base_type="mat${matrix_dim}x${matrix_dim}"
-    else
-	base_type="mat${matrix_dim}"
-    fi
-
-    type=$base_type
-    dim=""
-    if [ $array_dim -ne 0 ]; then
-	if [ $v -ge 120 ]; then
-	    type="${type}[$array_dim]"
-	else
-	    dim="[${array_dim}]"
-	fi
-    fi
-
-    if [ "x$mode" = "xtemp" ]; then
-	echo -n "    ${type} dst_matrix${dim}"
-	lhs=""
-    else
-	lhs="    dst_matrix"
-    fi
-
-    if [ $array_dim -ne 0 ]; then
-	if [ $v -ge 120 ]; then
-	    echo -n "${lhs} = ${type}("
-	    for i in $(seq $array_dim); do
-		if [ $i -ne 1 ]; then
-		    echo -n ", "
-		fi
-		echo -n "${base_type}(0.0)"
-	    done
-	    echo ");"
-	else
-	    if [ "x$mode" = "xtemp" ]; then
-		echo ";"
-	    fi
-
-	    for i in $(seq 0 $((array_dim - 1))); do
-		echo "    dst_matrix[$i] = ${base_type}(0.0);"
-	    done
-	fi
-    elif [ "x$mode" = "xtemp" ]; then
-	echo ";"
-    fi
-
-    echo
-}
-
-
-function emit_transform
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col="[$5]"
-    value_type=$6
-
-    if [ "x$value_type" = "xfloat" ]; then
-	row="[row]"
-    else
-	row=""
-    fi
-
-    cat <<EOF
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-EOF
-
-    if [ $array_dim -ne 0 ]; then
-	cat <<EOF
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-EOF
-	idx="[${index_value}]"
-    else
-	idx=""
-    fi
-
-    echo "     */"
-    echo "    dst_matrix${idx} = src_matrix;"
-    echo "    dst_matrix${idx}${col}${row} = value;"
-}
-
-
-function emit_fs
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col="[$5]"
-    value_type=$6
-
-    v=${version/./}
-    if [ $v -ge 120 ]; then
-	base_type="mat${matrix_dim}x${matrix_dim}"
-    else
-	base_type="mat${matrix_dim}"
-    fi
-
-    type=$base_type
-    dim=""
-    if [ $array_dim -ne 0 ]; then
-	if [ $v -ge 120 ]; then
-	    type="${type}[$array_dim]"
-	else
-	    dim="[${array_dim}]"
-	fi
-    fi
-
-    echo "[fragment shader]"
-
-    emit_globals $*
-
-    echo "void main()"
-    echo "{"
-
-    # Assume for now that fragment shaders can only write to temporaries.
-    # There usually aren't enough MRT outputs for an array of matrices
-    # anyway.  Just like with vertex shader array inputs (attribute arrays),
-    # we'll probably need a non-shader_runner test to exercise that path.
-    if [ "x$mode" = "xtemp" ]; then
-	emit_set_matrix $*
-	emit_transform $*
-    fi
-
-    echo "    gl_FragColor = (distance(dst_matrix${idx} * v, expect) < 1e-6)"
-    echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
-    echo "}"
-    echo
-}
-
-
-function emit_test_vectors
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-    index_value=$4
-    col=$5
-    value_type=$6
-
-    cat <<EOF
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-EOF
-
-    # NOTE: shader_runner uses the matCxR names even for GLSL 1.10
-    type="mat${matrix_dim}x${matrix_dim}"
-
-    # Random input vector, a random matrix, and the result of multiplying that
-    # vector by that matrix.  Naturally, the matrices are listed in OpenGL
-    # column-major order
-    case "${matrix_dim}x${matrix_dim}" in
-	"2x2")
-	    vec="0.803161418975390 0.852987140792140"
-	    exp="0.708718134966688 1.452243795483797"
-	    mat="0.241498998195656 0.861223395812970
-                 0.603473877011433 0.891622340451180"
-	    ;;
-	"3x3")
-	    vec="0.681652305322399 0.210426138878113 0.185916924650237"
-	    exp="0.610649606928364 0.711906885823636 0.312244778977868"
-	    mat="0.493944462129466 0.722190133917966 0.239853948232558
-                 0.550143078409278 0.591962645398579 0.467616286531193
-                 0.850846377186973 0.511303112962423 0.270815003356504"
-	    ;;
-	"4x4")
-	    vec="0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839"
-	    exp="1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820"
-	    mat="0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-                 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-                 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-                 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782"
-	    ;;
-    esac
-
-    # Trim out the extra whitespace from the matrix data.  The extra space
-    # (above) makes it easier to read, but it makes it harder to generate
-    # sensible test scripts.
-    mat=$(echo $mat | tr '\n' ' ' | sed 's/[[:space:]]\+/ /g;s/[[:space:]]*$//g')
-
-    if [ $array_dim -eq 0 ]; then
-	sizes="1"
-    elif [ "x$index_value" = "xindex" ]; then
-	sizes=$(seq $array_dim)
-    else
-	sizes="2"
-    fi
-
-    if [ "x$value_type" = "xfloat" ]; then
-	rows=$(seq $matrix_dim)
-	bad="666.0"
-    else
-	rows=1
-	case $matrix_dim in
-	    2) bad="666.0 777.0";;
-	    3) bad="666.0 777.0 888.0";;
-	    4) bad="666.0 777.0 888.0 999.0";;
-	esac
-    fi
-
-    if [ "x$col" = "xcol" ]; then
-	columns=$(seq $matrix_dim)
-    else
-	columns="2"
-    fi
-
-    for i in $sizes; do
-	if [ $array_dim -ne 0 -a "x$index_value" = "xindex" ]; then
-	    echo "uniform int index $((i-1))"
-	fi
-
-	x_base=$(((i - 1) * (15 * matrix_dim + 10)))
-	for c in $columns; do
-	    if [ "x$col" = "xcol" ]; then
-		echo "uniform int col $((c-1))"
-	    fi
-
-            for r in $rows; do
-		if [ "x$value_type" = "xfloat" ]; then
-		    echo "uniform int row $((r-1))"
-		fi
-
-		d=$((matrix_dim * (c-1) + (r-1) + 1))
-		if [ "x$value_type" = "xfloat" ]; then
-		    v=$(echo $mat | cut -d' ' -f$d)
-		else
-		    v=$(echo $mat | cut -d' ' -f$d-$((d+matrix_dim-1)))
-		fi
-
-		echo "uniform vec${matrix_dim} v ${vec}"
-		echo "uniform vec${matrix_dim} expect ${exp}"
-		echo "uniform ${type} src_matrix ${mat/$v/$bad}"
-		echo "uniform ${value_type} value $v"
-
-		x=$((x_base + 15 * c - 10))
-		y=$((15 * r - 10))
-		echo "draw rect $x $y 10 10"
-
-		x=$(($x + 5))
-		y=$(($y + 5))
-		echo "probe rgb $x $y 0.0 1.0 0.0"
-		echo
-	    done
-	done
-    done
-}
-
-
-function emit_fs_wr_test
-{
-    echo "# Test generated by:"
-    echo "# ${cmd}"
-    echo
-    echo "[require]"
-    echo "GLSL >= ${version}"
-    echo
-
-    echo "[vertex shader]"
-    echo "void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }"
-    echo
-
-    emit_fs $*
-    emit_test_vectors $*
-}
-
-
-function emit_vs_wr_test
-{
-    matrix_dim=$1
-    array_dim=$2
-    mode=$3
-
-    echo "# Test generated by:"
-    echo "# ${cmd}"
-    echo
-    echo "[require]"
-    echo "GLSL >= ${version}"
-    echo
-
-    echo "[vertex shader]"
-    emit_globals $*
-
-    echo "void main()"
-    echo "{"
-    echo "    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;"
-    echo
-
-    emit_set_matrix $*
-    emit_transform $*
-
-    if [ "x$mode" != "xvarying" ] ; then
-	echo "    gl_FrontColor = (distance(dst_matrix${idx} * v, expect) < 1e-6)"
-	echo "        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);"
-    fi
-
-    echo "}"
-    echo
-
-    if [ "x$mode" != "xvarying" ];then
-	echo "[fragment shader]"
-	echo "void main() { gl_FragColor = gl_Color; }"
-	echo
-    else
-	emit_fs $*
-    fi
-
-    emit_test_vectors $*
-}
-
-
-cmd="$0 $*"
-
-if [ "x$1" = "x" ]; then
-    version="1.10"
-else
-    case "$1" in
-	1.[12]0) version="$1";;
-	*)
-	    echo "Bogus GLSL version \"$1\" specified."
-	    exit 1
-	    ;;
-    esac
-fi
-
-for mode in temp varying; do
-    # More than 3 is unlikely to work for the varying tests due to using too
-    # many varying vectors.  mat4[3] uses 12 varying vectors by itself.
-    for array_dim in 0 3; do
-	if [ $array_dim -ne 0 ]; then
-	    arr="array-"
-	    idx_txt="index-"
-	else
-	    arr=""
-	    idx_txt=""
-	fi
-
-	for matrix_dim in 2 3 4; do
-	    # Fragment shaders cannot write varyings
-	    if [ "x$mode" != "xvarying" ]; then
-		emit_fs_wr_test $matrix_dim $array_dim $mode index col float \
-		    > fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-wr.shader_test
-
-		emit_fs_wr_test $matrix_dim $array_dim $mode index 1   float \
-		    > fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-wr.shader_test
-
-		emit_fs_wr_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
-		    > fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-wr.shader_test
-
-		emit_fs_wr_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
-		    > fs-${mode}-${arr}mat${matrix_dim}-${idx_txt}wr.shader_test
-
-		if [ $array_dim -ne 0 ]; then
-		    emit_fs_wr_test $matrix_dim $array_dim $mode 1 col float \
-			> fs-${mode}-${arr}mat${matrix_dim}-col-row-wr.shader_test
-
-		    emit_fs_wr_test $matrix_dim $array_dim $mode 1 1   float \
-			> fs-${mode}-${arr}mat${matrix_dim}-row-wr.shader_test
-
-		    emit_fs_wr_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
-			> fs-${mode}-${arr}mat${matrix_dim}-col-wr.shader_test
-
-		    emit_fs_wr_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
-			> fs-${mode}-${arr}mat${matrix_dim}-wr.shader_test
-		fi
-	    fi
-
-	    emit_vs_wr_test $matrix_dim $array_dim $mode index col float \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-row-wr.shader_test
-
-	    emit_vs_wr_test $matrix_dim $array_dim $mode index 1   float \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}row-wr.shader_test
-
-	    emit_vs_wr_test $matrix_dim $array_dim $mode index col vec${matrix_dim} \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}col-wr.shader_test
-
-	    emit_vs_wr_test $matrix_dim $array_dim $mode index 1   vec${matrix_dim} \
-		> vs-${mode}-${arr}mat${matrix_dim}-${idx_txt}wr.shader_test
-
-	    if [ $array_dim -ne 0 ]; then
-		emit_vs_wr_test $matrix_dim $array_dim $mode 1 col float \
-		    > vs-${mode}-${arr}mat${matrix_dim}-col-row-wr.shader_test
-
-		emit_vs_wr_test $matrix_dim $array_dim $mode 1 1   float \
-		    > vs-${mode}-${arr}mat${matrix_dim}-row-wr.shader_test
-
-		emit_vs_wr_test $matrix_dim $array_dim $mode 1 col vec${matrix_dim} \
-		    > vs-${mode}-${arr}mat${matrix_dim}-col-wr.shader_test
-
-		emit_vs_wr_test $matrix_dim $array_dim $mode 1 1   vec${matrix_dim} \
-		    > vs-${mode}-${arr}mat${matrix_dim}-wr.shader_test
-	    fi
-	done
-    done
-done
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-rd.shader_test
deleted file mode 100644
index 0f39fad9..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 279a8fde..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test
deleted file mode 100644
index 90aba4e8..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-wr.shader_test
deleted file mode 100644
index bd605c7a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index bbe315cd..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 6195594f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,110 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test
deleted file mode 100644
index 1ceaab4a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,147 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test
deleted file mode 100644
index 0fdac68d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test
+++ /dev/null
@@ -1,92 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-rd.shader_test
deleted file mode 100644
index fd9fe909..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index c72fe661..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test
deleted file mode 100644
index bfdc159b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test
+++ /dev/null
@@ -1,93 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-wr.shader_test
deleted file mode 100644
index 78732f09..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-index-wr.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-rd.shader_test
deleted file mode 100644
index aa1b3d9f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-row-rd.shader_test
deleted file mode 100644
index cd244ebf..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-row-wr.shader_test
deleted file mode 100644
index 88d65497..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-wr.shader_test
deleted file mode 100644
index 5f8f9aa3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat2-wr.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-rd.shader_test
deleted file mode 100644
index 382cd688..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index d33a6f8d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test
deleted file mode 100644
index 92263d2d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,117 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-wr.shader_test
deleted file mode 100644
index 0d13ffb5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index 0fe205ca..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 8829d3f8..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,188 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test
deleted file mode 100644
index e317d3d6..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,270 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test
deleted file mode 100644
index bc522bd5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test
+++ /dev/null
@@ -1,116 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-rd.shader_test
deleted file mode 100644
index 41881cd1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index f4f1aa31..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test
deleted file mode 100644
index e36217b8..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test
+++ /dev/null
@@ -1,117 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-wr.shader_test
deleted file mode 100644
index 11c37604..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-index-wr.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-rd.shader_test
deleted file mode 100644
index f5d43799..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-row-rd.shader_test
deleted file mode 100644
index e7ca492a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-row-wr.shader_test
deleted file mode 100644
index e0ac971b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,66 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-wr.shader_test
deleted file mode 100644
index 997ec432..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat3-wr.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-rd.shader_test
deleted file mode 100644
index 950ef190..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index c8cda8b4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,123 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test
deleted file mode 100644
index f5e21372..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,174 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-wr.shader_test
deleted file mode 100644
index 2a7ae831..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index 3c812670..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,102 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index f380dd88..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,296 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test
deleted file mode 100644
index 2c6200aa..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,441 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test
deleted file mode 100644
index ddf2d24d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test
+++ /dev/null
@@ -1,140 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-rd.shader_test
deleted file mode 100644
index 288204d7..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index f7af13db..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,102 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test
deleted file mode 100644
index fbb95a9d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test
+++ /dev/null
@@ -1,141 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-wr.shader_test
deleted file mode 100644
index db0f8e73..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-index-wr.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-rd.shader_test
deleted file mode 100644
index 7ac10449..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,39 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-row-rd.shader_test
deleted file mode 100644
index c688a8c5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-row-wr.shader_test
deleted file mode 100644
index 565322be..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-wr.shader_test
deleted file mode 100644
index 7787aa0a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-array-mat4-wr.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-rd.shader_test
deleted file mode 100644
index 2e135e8d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,44 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-row-rd.shader_test
deleted file mode 100644
index e5b35008..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-row-wr.shader_test
deleted file mode 100644
index 4194db5a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,71 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-wr.shader_test
deleted file mode 100644
index 30ff249d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-rd.shader_test
deleted file mode 100644
index 94d0b55b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-row-rd.shader_test
deleted file mode 100644
index c891d61c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,44 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-row-wr.shader_test
deleted file mode 100644
index d03e65e0..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-wr.shader_test
deleted file mode 100644
index 727ec221..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat2-wr.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-rd.shader_test
deleted file mode 100644
index 352b9836..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,49 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-row-rd.shader_test
deleted file mode 100644
index fb1f0286..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,84 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-row-wr.shader_test
deleted file mode 100644
index a6d59826..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,112 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-wr.shader_test
deleted file mode 100644
index 172f9024..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-rd.shader_test
deleted file mode 100644
index fb89c7a4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-row-rd.shader_test
deleted file mode 100644
index d205c331..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,49 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-row-wr.shader_test
deleted file mode 100644
index 28d5c129..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-wr.shader_test
deleted file mode 100644
index 9f138882..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat3-wr.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-rd.shader_test
deleted file mode 100644
index ca511812..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-row-rd.shader_test
deleted file mode 100644
index 934150a2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,120 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-row-wr.shader_test
deleted file mode 100644
index 686e838c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,169 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-wr.shader_test
deleted file mode 100644
index 2214fa5f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-rd.shader_test
deleted file mode 100644
index 69a2ea57..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-row-rd.shader_test
deleted file mode 100644
index 78281585..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-row-wr.shader_test
deleted file mode 100644
index 3c68de10..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-wr.shader_test
deleted file mode 100644
index 11cb707f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-temp-mat4-wr.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test
deleted file mode 100644
index 943b312c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 06468cdd..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 8f11e54b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,75 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 96d8b46e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,113 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test
deleted file mode 100644
index d84e4b4a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index c8ea690b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,75 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-rd.shader_test
deleted file mode 100644
index a0e6b3d2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,42 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test
deleted file mode 100644
index ea334661..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test
deleted file mode 100644
index ac46c726..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 3b98b00d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,90 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index abe4252c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,90 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 7b22586f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,191 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test
deleted file mode 100644
index 4cd2d26d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index a7e27657..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,90 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-rd.shader_test
deleted file mode 100644
index eff12569..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,42 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test
deleted file mode 100644
index b231faa2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test
deleted file mode 100644
index 2039e258..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 2aa60f12..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,126 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index e95785ac..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,105 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index 09eba56c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,299 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test
deleted file mode 100644
index 6716a5fd..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index a83df7c1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,105 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-rd.shader_test
deleted file mode 100644
index c3eb3735..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,42 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test
deleted file mode 100644
index c41545bf..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-col-rd.shader_test
deleted file mode 100644
index f02f3ec3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,44 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test
deleted file mode 100644
index 79051eed..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-rd.shader_test
deleted file mode 100644
index 2924935f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-row-rd.shader_test
deleted file mode 100644
index 8912c48f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,44 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-col-rd.shader_test
deleted file mode 100644
index f8141b82..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,49 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test
deleted file mode 100644
index cc1418e5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,84 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-rd.shader_test
deleted file mode 100644
index 93cc20ac..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-row-rd.shader_test
deleted file mode 100644
index 8eecf988..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,49 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-col-rd.shader_test
deleted file mode 100644
index b3b98f95..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test
deleted file mode 100644
index 7434c0a3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,120 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-rd.shader_test
deleted file mode 100644
index e8fcbd16..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-rd.shader_test
+++ /dev/null
@@ -1,36 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-row-rd.shader_test
deleted file mode 100644
index 2d63b8f3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-uniform-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-col-rd.shader_test
deleted file mode 100644
index dc1ee89d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index a6b8ae6b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 9f5b0f00..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index a1a43070..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,111 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-rd.shader_test
deleted file mode 100644
index 8f7e819e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 11649370..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-rd.shader_test
deleted file mode 100644
index 9b0579f8..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-row-rd.shader_test
deleted file mode 100644
index 145889ed..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-col-rd.shader_test
deleted file mode 100644
index 679f9af2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 33afe843..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index ef1f10a6..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 77a96e27..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,189 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-rd.shader_test
deleted file mode 100644
index 88fe5ce1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index 4aa49af1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-rd.shader_test
deleted file mode 100644
index 2d47123e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-row-rd.shader_test
deleted file mode 100644
index c73255bb..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-col-rd.shader_test
deleted file mode 100644
index 8ecda152..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 687cf6ee..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index edec6167..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index ae9d5877..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,297 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-rd.shader_test
deleted file mode 100644
index 7714242b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 5045dc32..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-rd.shader_test
deleted file mode 100644
index cd8ae33b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-row-rd.shader_test
deleted file mode 100644
index 42b43444..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-col-rd.shader_test
deleted file mode 100644
index 88ff4596..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-col-row-rd.shader_test
deleted file mode 100644
index 15324f0a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,60 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-rd.shader_test
deleted file mode 100644
index eb6fbeef..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-row-rd.shader_test
deleted file mode 100644
index 3cb90460..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,46 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-col-rd.shader_test
deleted file mode 100644
index b565eaeb..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-col-row-rd.shader_test
deleted file mode 100644
index 0bfcf3ed..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,86 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-rd.shader_test
deleted file mode 100644
index f7c71bca..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-row-rd.shader_test
deleted file mode 100644
index 4cccf436..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-col-rd.shader_test
deleted file mode 100644
index 09f96149..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-col-row-rd.shader_test
deleted file mode 100644
index 5ad24a2b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,122 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-rd.shader_test
deleted file mode 100644
index 57fcf005..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-rd.shader_test
+++ /dev/null
@@ -1,38 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-row-rd.shader_test
deleted file mode 100644
index 319f2b9c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/fs-varying-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-rd.shader_test
deleted file mode 100644
index 98aa6f84..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 953d59f1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test
deleted file mode 100644
index ca6e905e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,80 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-wr.shader_test
deleted file mode 100644
index d997b916..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 9d02ac43..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 8cef49c6..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,111 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test
deleted file mode 100644
index b4e36d7d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,151 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test
deleted file mode 100644
index 6798626b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test
+++ /dev/null
@@ -1,96 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-rd.shader_test
deleted file mode 100644
index d8819f33..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 353a5394..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test
deleted file mode 100644
index cded995d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test
+++ /dev/null
@@ -1,97 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-wr.shader_test
deleted file mode 100644
index d26aae34..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-index-wr.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-rd.shader_test
deleted file mode 100644
index de95b745..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-row-rd.shader_test
deleted file mode 100644
index 16b96dd4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,48 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] m = mat2x2[3](
-        mat2x2(1.0, 2.0, 3.0, 4.0),
-        mat2x2(5.0, 6.0, 7.0, 8.0),
-        mat2x2(9.0, 10.0, 11.0, 12.0));
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-row-wr.shader_test
deleted file mode 100644
index 923e538f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-wr.shader_test
deleted file mode 100644
index 7688deba..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat2-wr.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-rd.shader_test
deleted file mode 100644
index 97009cd6..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 4a40ee41..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test
deleted file mode 100644
index fe77f7e5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-wr.shader_test
deleted file mode 100644
index 1f74a466..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index 95267942..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index dee34fc1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,189 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test
deleted file mode 100644
index 5bbc7bdd..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,274 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test
deleted file mode 100644
index 1215412f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test
+++ /dev/null
@@ -1,120 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-rd.shader_test
deleted file mode 100644
index 63380f9c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index 5aa096c3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,88 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test
deleted file mode 100644
index b808fd05..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-wr.shader_test
deleted file mode 100644
index d1896351..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-index-wr.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-rd.shader_test
deleted file mode 100644
index a7af0383..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-row-rd.shader_test
deleted file mode 100644
index 5a198a98..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] m = mat3x3[3](
-        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-row-wr.shader_test
deleted file mode 100644
index 80cf5c7f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,70 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-wr.shader_test
deleted file mode 100644
index 3ac61ed5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat3-wr.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-rd.shader_test
deleted file mode 100644
index 2f5eb1b0..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 724fca20..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,124 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test
deleted file mode 100644
index 04985b6a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,178 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-wr.shader_test
deleted file mode 100644
index 8b8c32c6..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,77 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index 60a8813e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index 1185a207..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,297 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test
deleted file mode 100644
index 0f8cc45e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,445 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test
deleted file mode 100644
index c4e3b3c2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test
+++ /dev/null
@@ -1,144 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-rd.shader_test
deleted file mode 100644
index 4b93c4d0..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 40a1c216..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,103 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test
deleted file mode 100644
index 8322c9ac..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test
+++ /dev/null
@@ -1,145 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-wr.shader_test
deleted file mode 100644
index 1b9d5d24..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-index-wr.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-rd.shader_test
deleted file mode 100644
index 502d5dc5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,40 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-row-rd.shader_test
deleted file mode 100644
index 07038ef7..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,58 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] m = mat4x4[3](
-        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-row-wr.shader_test
deleted file mode 100644
index 5d461ff1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,78 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-wr.shader_test
deleted file mode 100644
index 61c109de..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-array-mat4-wr.shader_test
+++ /dev/null
@@ -1,52 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-rd.shader_test
deleted file mode 100644
index 78238f2d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-row-rd.shader_test
deleted file mode 100644
index c5008fff..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,59 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-row-wr.shader_test
deleted file mode 100644
index 8c130350..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,75 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-wr.shader_test
deleted file mode 100644
index 7c8215b8..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-rd.shader_test
deleted file mode 100644
index 45a4a87c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-row-rd.shader_test
deleted file mode 100644
index 6d3a2eee..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-row-wr.shader_test
deleted file mode 100644
index ba47207b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,57 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-wr.shader_test
deleted file mode 100644
index 705e0c4d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat2-wr.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat2x2 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-rd.shader_test
deleted file mode 100644
index 032a523f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-row-rd.shader_test
deleted file mode 100644
index d7c38227..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,85 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-row-wr.shader_test
deleted file mode 100644
index 6e35f4e1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,116 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-wr.shader_test
deleted file mode 100644
index 7383b5a4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-rd.shader_test
deleted file mode 100644
index 3fceb28c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-row-rd.shader_test
deleted file mode 100644
index d296911e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-row-wr.shader_test
deleted file mode 100644
index b8572582..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-wr.shader_test
deleted file mode 100644
index d5249de0..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat3-wr.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat3x3 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-rd.shader_test
deleted file mode 100644
index cfe9858b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-row-rd.shader_test
deleted file mode 100644
index 77053738..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-row-wr.shader_test
deleted file mode 100644
index 18d5e3d9..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,173 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-wr.shader_test
deleted file mode 100644
index e97be85c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-rd.shader_test
deleted file mode 100644
index 3859cff3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-row-rd.shader_test
deleted file mode 100644
index 3cbca9d4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-row-wr.shader_test
deleted file mode 100644
index 16005f8a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-wr.shader_test
deleted file mode 100644
index 1a12b77d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-temp-mat4-wr.shader_test
+++ /dev/null
@@ -1,47 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    mat4x4 dst_matrix;
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-#version 120
-void main() { gl_FragColor = gl_Color; }
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test
deleted file mode 100644
index 5179b221..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 15fa69b6..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,65 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 40444816..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index 7b648229..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,114 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test
deleted file mode 100644
index 64c0c6f3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 5f26e078..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-rd.shader_test
deleted file mode 100644
index 36abf245..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test
deleted file mode 100644
index ba3fb32d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,51 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2[3] m = mat2x2[3](
-    mat2x2(1.0, 2.0, 3.0, 4.0),
-    mat2x2(5.0, 6.0, 7.0, 8.0),
-    mat2x2(9.0, 10.0, 11.0, 12.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test
deleted file mode 100644
index d579506d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index f85987fc..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,91 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index 612ad20f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,91 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 9a768b85..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,192 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test
deleted file mode 100644
index 02b01668..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index ddd8dafe..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,91 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-rd.shader_test
deleted file mode 100644
index bdba71f5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test
deleted file mode 100644
index 468875a2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3[3] m = mat3x3[3](
-    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
-    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
-    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test
deleted file mode 100644
index 34107fe5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 9979e064..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,127 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index f83c38a6..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,106 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index 830c3f5b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,300 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test
deleted file mode 100644
index 13d1cbfb..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 73689b15..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,106 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-rd.shader_test
deleted file mode 100644
index ccdec23a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,43 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test
deleted file mode 100644
index 0b0cbf3d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,61 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4[3] m = mat4x4[3](
-    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
-    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
-    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-col-rd.shader_test
deleted file mode 100644
index 2aae5551..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test
deleted file mode 100644
index bca0fe95..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,59 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-rd.shader_test
deleted file mode 100644
index 57643287..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-row-rd.shader_test
deleted file mode 100644
index 30bd0870..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,45 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-col-rd.shader_test
deleted file mode 100644
index de94a1db..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test
deleted file mode 100644
index 123dbf25..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,85 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-rd.shader_test
deleted file mode 100644
index 7c65df34..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-row-rd.shader_test
deleted file mode 100644
index 287b0a87..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,50 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-col-rd.shader_test
deleted file mode 100644
index 5961db59..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test
deleted file mode 100644
index 43d536f9..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,121 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-rd.shader_test
deleted file mode 100644
index 9a06d65b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-rd.shader_test
+++ /dev/null
@@ -1,37 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-row-rd.shader_test
deleted file mode 100644
index 5eaa3355..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-uniform-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-varying vec4 color;
-
-void main()
-{
-    gl_FragColor = color;
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-rd.shader_test
deleted file mode 100644
index e8638b29..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test
deleted file mode 100644
index 55992b73..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,78 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test
deleted file mode 100644
index 193bc538..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,91 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-wr.shader_test
deleted file mode 100644
index 18a92be3..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,71 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test
deleted file mode 100644
index 01748a31..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test
+++ /dev/null
@@ -1,89 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 expect 5 6
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 expect 9 10
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test
deleted file mode 100644
index fc2f094d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,127 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 5
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 9
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test
deleted file mode 100644
index dd1d64df..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,162 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 45 20 10 10
-probe rgb 50 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 85 20 10 10
-probe rgb 90 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test
deleted file mode 100644
index 551969e2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test
+++ /dev/null
@@ -1,106 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 45 5 10 10
-probe rgb 50 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 85 5 10 10
-probe rgb 90 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-rd.shader_test
deleted file mode 100644
index 1df7d491..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 expect 11 12
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test
deleted file mode 100644
index 2b2daf10..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test
+++ /dev/null
@@ -1,89 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 11
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 12
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test
deleted file mode 100644
index ad455266..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test
+++ /dev/null
@@ -1,108 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 100 20 10 10
-probe rgb 105 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-wr.shader_test
deleted file mode 100644
index c473cce5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-index-wr.shader_test
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 100 5 10 10
-probe rgb 105 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-rd.shader_test
deleted file mode 100644
index cee403c2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 7 8
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-row-rd.shader_test
deleted file mode 100644
index 3f6d98e2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
-    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
-    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2x2[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 7
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-row-wr.shader_test
deleted file mode 100644
index bb24ad83..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,73 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-wr.shader_test
deleted file mode 100644
index a677c652..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat2-wr.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int index;
-uniform int col;
-uniform vec2 value;
-varying mat2x2[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-rd.shader_test
deleted file mode 100644
index cff035aa..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test
deleted file mode 100644
index 9d08ba2c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,104 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test
deleted file mode 100644
index 2bfca6c1..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,132 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-wr.shader_test
deleted file mode 100644
index 773a3b60..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test
deleted file mode 100644
index b78a8d47..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test
+++ /dev/null
@@ -1,104 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 expect 10 11 12
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 16 17 18
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 expect 19 20 21
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 25 26 27
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test
deleted file mode 100644
index 4e68e1c0..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,205 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 10
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 11
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 12
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 16
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 17
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 18
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 19
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 20
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 21
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test
deleted file mode 100644
index f69edbc2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,285 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 60 20 10 10
-probe rgb 65 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 60 35 10 10
-probe rgb 65 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 115 20 10 10
-probe rgb 120 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 115 35 10 10
-probe rgb 120 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test
deleted file mode 100644
index 946e200f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test
+++ /dev/null
@@ -1,130 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 60 5 10 10
-probe rgb 65 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 115 5 10 10
-probe rgb 120 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-rd.shader_test
deleted file mode 100644
index 9d683e73..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 expect 22 23 24
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test
deleted file mode 100644
index c6126c9c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test
+++ /dev/null
@@ -1,104 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 22
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 23
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 24
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test
deleted file mode 100644
index 5ab56c2b..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test
+++ /dev/null
@@ -1,132 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 130 20 10 10
-probe rgb 135 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 130 35 10 10
-probe rgb 135 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-wr.shader_test
deleted file mode 100644
index 34ef6730..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-index-wr.shader_test
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 130 5 10 10
-probe rgb 135 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-rd.shader_test
deleted file mode 100644
index 10f9dd58..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 13 14 15
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-row-rd.shader_test
deleted file mode 100644
index b5b9102d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
-    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3x3[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 13
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-row-wr.shader_test
deleted file mode 100644
index f933a470..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,81 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-wr.shader_test
deleted file mode 100644
index 9bb92993..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat3-wr.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int index;
-uniform int col;
-uniform vec3 value;
-varying mat3x3[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-rd.shader_test
deleted file mode 100644
index 6d8962be..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test
deleted file mode 100644
index 3d0c5e1a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,140 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test
deleted file mode 100644
index a44de2a4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,189 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col][row] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-wr.shader_test
deleted file mode 100644
index 4cf80524..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,87 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][col] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test
deleted file mode 100644
index 33274db2..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test
+++ /dev/null
@@ -1,119 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 expect 17 18 19 20
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 25 26 27 28
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 29 30 31 32
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 expect 33 34 35 36
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 41 42 43 44
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 45 46 47 48
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test
deleted file mode 100644
index 3ac7574d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test
+++ /dev/null
@@ -1,313 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform float expect 17
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 18
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 19
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 20
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 25
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 26
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 27
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 28
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 29
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 30
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 31
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 32
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform float expect 33
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 34
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 35
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 36
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 41
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 42
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 43
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 44
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 45
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 46
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 47
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 48
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test
deleted file mode 100644
index 9b7846a0..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test
+++ /dev/null
@@ -1,456 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col][row] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 75 20 10 10
-probe rgb 80 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 75 35 10 10
-probe rgb 80 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 75 50 10 10
-probe rgb 80 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 105 20 10 10
-probe rgb 110 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 105 35 10 10
-probe rgb 110 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 105 50 10 10
-probe rgb 110 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 120 20 10 10
-probe rgb 125 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 120 35 10 10
-probe rgb 125 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 120 50 10 10
-probe rgb 125 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 145 20 10 10
-probe rgb 150 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 145 35 10 10
-probe rgb 150 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 145 50 10 10
-probe rgb 150 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 175 20 10 10
-probe rgb 180 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 175 35 10 10
-probe rgb 180 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 175 50 10 10
-probe rgb 180 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 190 20 10 10
-probe rgb 195 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 190 35 10 10
-probe rgb 195 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 190 50 10 10
-probe rgb 195 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test
deleted file mode 100644
index e1d54a54..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test
+++ /dev/null
@@ -1,154 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][col] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 75 5 10 10
-probe rgb 80 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 105 5 10 10
-probe rgb 110 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 120 5 10 10
-probe rgb 125 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 145 5 10 10
-probe rgb 150 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 175 5 10 10
-probe rgb 180 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 190 5 10 10
-probe rgb 195 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-rd.shader_test
deleted file mode 100644
index c815b729..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-rd.shader_test
+++ /dev/null
@@ -1,69 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 expect 37 38 39 40
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test
deleted file mode 100644
index 174787b9..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test
+++ /dev/null
@@ -1,119 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[index][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int index;
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[index][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform float expect 37
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 38
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 39
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 40
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test
deleted file mode 100644
index 05dce43d..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test
+++ /dev/null
@@ -1,156 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1][row] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int index 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
-uniform int index 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 160 20 10 10
-probe rgb 165 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 160 35 10 10
-probe rgb 165 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 160 50 10 10
-probe rgb 165 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-wr.shader_test
deleted file mode 100644
index a014afb8..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-index-wr.shader_test
+++ /dev/null
@@ -1,79 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[index] = src_matrix;
-    dst_matrix[index][1] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int index 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int index 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int index 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 160 5 10 10
-probe rgb 165 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-rd.shader_test
deleted file mode 100644
index eb7e5cc4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-rd.shader_test
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 21 22 23 24
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-row-rd.shader_test
deleted file mode 100644
index b581d63e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
-    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4x4[3] m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 21
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 22
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 23
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 24
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-row-wr.shader_test
deleted file mode 100644
index ae3a2f24..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,89 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1][row] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 90 20 10 10
-probe rgb 95 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 90 35 10 10
-probe rgb 95 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 90 50 10 10
-probe rgb 95 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-wr.shader_test
deleted file mode 100644
index 4d437a4c..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-array-mat4-wr.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     *
-     * NOTE: This test assumes that reads of arrays using non-constant
-     * indicies works correctly.  If reads and writes happen to fail in an
-     * identical manner, this test may give false positives.
-     */
-    dst_matrix[1] = src_matrix;
-    dst_matrix[1][1] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int index;
-uniform int col;
-uniform vec4 value;
-varying mat4x4[3] dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 90 5 10 10
-probe rgb 95 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-rd.shader_test
deleted file mode 100644
index 23e6fde8..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 expect 1 2
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-row-rd.shader_test
deleted file mode 100644
index 879efb7a..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-row-rd.shader_test
+++ /dev/null
@@ -1,76 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-row-wr.shader_test
deleted file mode 100644
index 6f47dc30..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-row-wr.shader_test
+++ /dev/null
@@ -1,84 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
-uniform float value 0.241498998195656
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
-uniform float value 0.861223395812970
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-wr.shader_test
deleted file mode 100644
index 8ab25a38..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-col-wr.shader_test
+++ /dev/null
@@ -1,64 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
-uniform vec2 value 0.241498998195656 0.861223395812970
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-rd.shader_test
deleted file mode 100644
index 539ca059..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec2 expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 expect 3 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-row-rd.shader_test
deleted file mode 100644
index 9b9f54ad..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-row-rd.shader_test
+++ /dev/null
@@ -1,62 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat2x2(1.0, 2.0, 3.0, 4.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat2x2 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 3
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 4
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-row-wr.shader_test
deleted file mode 100644
index 44a7b3b4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-row-wr.shader_test
+++ /dev/null
@@ -1,66 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
-uniform float value 0.603473877011433
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
-uniform float value 0.891622340451180
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-wr.shader_test
deleted file mode 100644
index 7b331f0f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat2-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-}
-
-[fragment shader]
-uniform mat2x2 src_matrix;
-uniform vec2 v;
-uniform vec2 expect;
-uniform int col;
-uniform vec2 value;
-varying mat2x2 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec2 v 0.803161418975390 0.852987140792140
-uniform vec2 expect 0.708718134966688 1.452243795483797
-uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
-uniform vec2 value 0.603473877011433 0.891622340451180
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-rd.shader_test
deleted file mode 100644
index 3f3db3d0..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-rd.shader_test
+++ /dev/null
@@ -1,67 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 expect 1 2 3
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 expect 7 8 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-row-rd.shader_test
deleted file mode 100644
index a518f128..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-row-rd.shader_test
+++ /dev/null
@@ -1,102 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 7
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 8
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 9
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-row-wr.shader_test
deleted file mode 100644
index 1a173b59..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-row-wr.shader_test
+++ /dev/null
@@ -1,125 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.493944462129466
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.722190133917966
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.239853948232558
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
-uniform float value 0.850846377186973
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
-uniform float value 0.511303112962423
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
-uniform float value 0.270815003356504
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-wr.shader_test
deleted file mode 100644
index 404fa2f7..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-col-wr.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
-uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-rd.shader_test
deleted file mode 100644
index c54928f5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec3 expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 expect 4 5 6
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-row-rd.shader_test
deleted file mode 100644
index 21b6d448..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-row-rd.shader_test
+++ /dev/null
@@ -1,67 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat3x3 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 4
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 5
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 6
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-row-wr.shader_test
deleted file mode 100644
index 132c32fe..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-row-wr.shader_test
+++ /dev/null
@@ -1,74 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.550143078409278
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.591962645398579
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform float value 0.467616286531193
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-wr.shader_test
deleted file mode 100644
index 3cfd3b84..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat3-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-}
-
-[fragment shader]
-uniform mat3x3 src_matrix;
-uniform vec3 v;
-uniform vec3 expect;
-uniform int col;
-uniform vec3 value;
-varying mat3x3 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
-uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
-uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
-uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-rd.shader_test
deleted file mode 100644
index b0f67b7e..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 expect 1 2 3 4
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 expect 9 10 11 12
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 expect 13 14 15 16
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-row-rd.shader_test
deleted file mode 100644
index 898d8e38..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-row-rd.shader_test
+++ /dev/null
@@ -1,138 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[col][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int col;
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[col][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform float expect 1
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 2
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 3
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 4
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform float expect 9
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 10
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 11
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 12
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform float expect 13
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 14
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 15
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 16
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-row-wr.shader_test
deleted file mode 100644
index 667bec47..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-row-wr.shader_test
+++ /dev/null
@@ -1,182 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col][row] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.922040144261674
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.158053783109488
-draw rect 5 20 10 10
-probe rgb 10 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.357016429866574
-draw rect 5 35 10 10
-probe rgb 10 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.836368810383957
-draw rect 5 50 10 10
-probe rgb 10 55 0.0 1.0 0.0
-
-uniform int col 1
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
-uniform int col 2
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.350720358904176
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.912192627475775
-draw rect 35 20 10 10
-probe rgb 40 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.688544081259531
-draw rect 35 35 10 10
-probe rgb 40 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.913891056231967
-draw rect 35 50 10 10
-probe rgb 40 55 0.0 1.0 0.0
-
-uniform int col 3
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.442058176039301
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
-uniform float value 0.829835836794679
-draw rect 50 20 10 10
-probe rgb 55 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
-uniform float value 0.365674411003021
-draw rect 50 35 10 10
-probe rgb 55 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
-uniform float value 0.879197364462782
-draw rect 50 50 10 10
-probe rgb 55 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-wr.shader_test
deleted file mode 100644
index 91791c19..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-col-wr.shader_test
+++ /dev/null
@@ -1,80 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[col] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int col 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
-draw rect 5 5 10 10
-probe rgb 10 10 0.0 1.0 0.0
-
-uniform int col 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int col 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
-draw rect 35 5 10 10
-probe rgb 40 10 0.0 1.0 0.0
-
-uniform int col 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
-uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-draw rect 50 5 10 10
-probe rgb 55 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-rd.shader_test
deleted file mode 100644
index 3e7a147f..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-rd.shader_test
+++ /dev/null
@@ -1,54 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform vec4 expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 expect 5 6 7 8
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-row-rd.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-row-rd.shader_test
deleted file mode 100644
index 5f3a88d5..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-row-rd.shader_test
+++ /dev/null
@@ -1,72 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-read.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
-
-    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
-     *
-     *     "A vertex shader may also read varying variables, getting back the
-     *     same values it has written. Reading a varying variable in a vertex
-     *     shader returns undefined values if it is read before being
-     *     written."
-     */
-    color = (m[1][row] == expect)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[fragment shader]
-uniform int row;
-uniform float expect;
-varying mat4x4 m;
-varying vec4 color;
-
-void main()
-{
-    /* There is some trickery here.  The fragment shader has to actually use
-     * the varyings generated by the vertex shader, or the compiler (more
-     * likely the linker) might demote the varying outputs to just be vertex
-     * shader global variables.  Since the point of the test is the vertex
-     * shader reading from a varying, that would defeat the test.
-     */
-    gl_FragColor = (m[1][row] == expect)
-        ? color : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform float expect 5
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform float expect 6
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform float expect 7
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform float expect 8
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-row-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-row-wr.shader_test
deleted file mode 100644
index a05da7c4..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-row-wr.shader_test
+++ /dev/null
@@ -1,82 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1][row] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int row;
-uniform int col;
-uniform float value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform int row 0
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.560251913703792
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
-uniform int row 1
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.171634921595771
-draw rect 20 20 10 10
-probe rgb 25 25 0.0 1.0 0.0
-
-uniform int row 2
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.602494709909111
-draw rect 20 35 10 10
-probe rgb 25 40 0.0 1.0 0.0
-
-uniform int row 3
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform float value 0.693273570571311
-draw rect 20 50 10 10
-probe rgb 25 55 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-wr.shader_test b/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-wr.shader_test
deleted file mode 100644
index 4ebd2eeb..00000000
--- a/tests/spec/glsl-1.20/execution/variable-indexing/vs-varying-mat4-wr.shader_test
+++ /dev/null
@@ -1,55 +0,0 @@
-# Test generated by:
-# ../../../glsl-1.10/variable-index-write.sh 1.20
-
-[require]
-GLSL >= 1.20
-
-[vertex shader]
-#version 120
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
-
-
-    /* Patch the supplied matrix with the supplied value.  If the resulting
-     * matrix is correct, it will transform the input vector to the expected
-     * value.  Verify that the distance between the result and the expected
-     * vector is less than epsilon.
-     */
-    dst_matrix = src_matrix;
-    dst_matrix[1] = value;
-}
-
-[fragment shader]
-uniform mat4x4 src_matrix;
-uniform vec4 v;
-uniform vec4 expect;
-uniform int col;
-uniform vec4 value;
-varying mat4x4 dst_matrix;
-
-void main()
-{
-    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
-        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
-}
-
-[test]
-clear color 0.5 0.5 0.5 0.5
-clear
-ortho
-
-uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
-uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
-uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
-uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
-draw rect 20 5 10 10
-probe rgb 25 10 0.0 1.0 0.0
-
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bool.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bool.vert
new file mode 100644
index 00000000..fb8d655e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bool.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(bool(0), bool(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec2.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec2.vert
new file mode 100644
index 00000000..3ec5fadc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec2.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(bvec2(0), bvec2(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec3.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec3.vert
new file mode 100644
index 00000000..25c7e677
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec3.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(bvec3(0), bvec3(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec4.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec4.vert
new file mode 100644
index 00000000..2aa4cfe0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-bvec4.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(bvec4(0), bvec4(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-float.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-float.vert
new file mode 100644
index 00000000..f7632cee
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-float.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(float(0), float(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-int.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-int.vert
new file mode 100644
index 00000000..e2bb80ac
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-int.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(int(0), int(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-invalid-parameters.sh b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-invalid-parameters.sh
new file mode 100755
index 00000000..e9ffae9a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-invalid-parameters.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+function emit_vs
+{
+    t=$1
+
+    cat > outerProduct-$t.vert <<EOF
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(${t}(0), ${t}(0));
+}
+EOF
+}
+
+for i in int float bool bvec2 bvec3 bvec4 mat2 mat2x2 mat2x3 mat2x4 mat3 mat3x2 mat3x3 mat3x4 mat4 mat4x2 mat4x3 mat4x4
+do
+    emit_vs $i
+done
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2.vert
new file mode 100644
index 00000000..09d06bb7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat2(0), mat2(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x2.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x2.vert
new file mode 100644
index 00000000..94921f70
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x2.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat2x2(0), mat2x2(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x3.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x3.vert
new file mode 100644
index 00000000..f55e8876
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x3.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat2x3(0), mat2x3(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x4.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x4.vert
new file mode 100644
index 00000000..9620135a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat2x4.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat2x4(0), mat2x4(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3.vert
new file mode 100644
index 00000000..8eb8f991
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat3(0), mat3(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x2.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x2.vert
new file mode 100644
index 00000000..a2c23355
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x2.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat3x2(0), mat3x2(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x3.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x3.vert
new file mode 100644
index 00000000..fbfd900f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x3.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat3x3(0), mat3x3(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x4.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x4.vert
new file mode 100644
index 00000000..a31db9e8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat3x4.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat3x4(0), mat3x4(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4.vert
new file mode 100644
index 00000000..4fa6c07a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat4(0), mat4(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x2.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x2.vert
new file mode 100644
index 00000000..2ca45390
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x2.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat4x2(0), mat4x2(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x3.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x3.vert
new file mode 100644
index 00000000..e45e5f90
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x3.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat4x3(0), mat4x3(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x4.vert b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x4.vert
new file mode 100644
index 00000000..e63a8a5e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/built-in-functions/outerProduct-mat4x4.vert
@@ -0,0 +1,10 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+void main () {
+  gl_Position = vec4(0);
+  outerProduct(mat4x4(0), mat4x4(0));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/clipping/clip-distance-unavailable.frag b/tests/spec/glsl-es-1.00/compiler/clipping/clip-distance-unavailable.frag
new file mode 100644
index 00000000..e72eb045
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/clipping/clip-distance-unavailable.frag
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * check_link: true
+ * [end config]
+ *
+ * This test verifies that the fragment shader special variable
+ * gl_ClipDistance (defined in GLSL 1.30) is not available when the
+ * GLSL version is 1.20.
+ */
+
+varying float gl_ClipDistance[2];
+
+void main()
+{
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/clipping/clip-distance-unavailable.vert b/tests/spec/glsl-es-1.00/compiler/clipping/clip-distance-unavailable.vert
new file mode 100644
index 00000000..108f9122
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/clipping/clip-distance-unavailable.vert
@@ -0,0 +1,18 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * check_link: true
+ * [end config]
+ *
+ * This test verifies that the vertex shader special variable
+ * gl_ClipDistance (defined in GLSL 1.30) is not available when the
+ * GLSL version is 1.20.
+ */
+
+varying float gl_ClipDistance[2];
+
+void main()
+{
+  gl_Position = vec4(0.0);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-attribute-01.vert b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-attribute-01.vert
new file mode 100644
index 00000000..7ebd324a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-attribute-01.vert
@@ -0,0 +1,17 @@
+// [config]
+// expect_result: fail
+// glsl_version: 1.20
+// glsles_version: 1.00
+// [end config]
+//
+// From section 4.3.4 of the GLSL 1.20 spec:
+//     Attribute variables are read-only as far as the vertex shader is
+//     concerned.
+
+
+attribute float x;
+
+float f() {
+	x = 0.0;
+	return x;
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-attribute-02.vert b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-attribute-02.vert
new file mode 100644
index 00000000..1182d7ce
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-attribute-02.vert
@@ -0,0 +1,19 @@
+// [config]
+// expect_result: fail
+// glsl_version: 1.20
+// glsles_version: 1.00
+// [end config]
+//
+// From section 4.3.4 of the GLSL 1.20 spec:
+//     Attribute variables are read-only as far as the vertex shader is
+//     concerned.
+
+attribute float x;
+
+void f(out float y) {
+    y = 0.0;
+}
+
+void g() {
+    f(x);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-point-coord.frag b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-point-coord.frag
new file mode 100644
index 00000000..b909f94b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-point-coord.frag
@@ -0,0 +1,18 @@
+// [config]
+// expect_result: fail
+// glsl_version: 1.20
+// glsles_version: 1.00
+// [end config]
+//
+// From section 4.3.6 of the GLSL 1.20 spec:
+//     A fragment shader can not write to a varying variable.
+//
+// From section 7.6 of the GLSL 1.20 spec:
+//     The following varying variables are available to read from in a fragment shader.
+//         ...
+//     varying vec2 gl_PointCoord;
+
+
+void g() {
+    gl_PointCoord = vec2(0.0);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-varying-01.frag b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-varying-01.frag
new file mode 100644
index 00000000..c2f320ce
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-varying-01.frag
@@ -0,0 +1,14 @@
+// [config]
+// expect_result: fail
+// glsl_version: 1.20
+// glsles_version: 1.00
+// [end config]
+//
+// From section 4.3.6 of the GLSL 1.20 spec:
+//     A fragment shader can not write to a varying variable.
+
+varying float x;
+
+void g() {
+    x = 0.0;
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-varying-02.frag b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-varying-02.frag
new file mode 100644
index 00000000..1907ba04
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/storage-qualifiers/static-write-varying-02.frag
@@ -0,0 +1,19 @@
+// [config]
+// expect_result: fail
+// glsl_version: 1.20
+// glsles_version: 1.00
+// [end config]
+//
+// From section 4.3.6 of the GLSL 1.20 spec:
+//     A fragment shader can not write to a varying variable.
+
+
+varying float x;
+
+void f(out float y) {
+    y = 0.0;
+}
+
+void g() {
+    f(x);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-add.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-add.vert
new file mode 100644
index 00000000..0ed5a818
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-add.vert
@@ -0,0 +1,26 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  vec4 c[2] = a + b;
+  gl_Position = c[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bool-float.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bool-float.vert
new file mode 100644
index 00000000..06a298e0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bool-float.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bool a[2];
+
+void main()
+{
+  float b[2];
+  b = a;
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bool-int.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bool-int.vert
new file mode 100644
index 00000000..be1d8beb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bool-int.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bool a[2];
+
+void main()
+{
+  int b[2];
+  b = a;
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec2-ivec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec2-ivec2.vert
new file mode 100644
index 00000000..cda2e5d9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec2-ivec2.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bvec2 a[2];
+
+void main()
+{
+  ivec2 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec2-vec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec2-vec2.vert
new file mode 100644
index 00000000..97ad3887
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec2-vec2.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bvec2 a[2];
+
+void main()
+{
+  vec2 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec3-ivec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec3-ivec3.vert
new file mode 100644
index 00000000..f192fbf3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec3-ivec3.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bvec3 a[2];
+
+void main()
+{
+  ivec3 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec3-vec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec3-vec3.vert
new file mode 100644
index 00000000..26ea54ae
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec3-vec3.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bvec3 a[2];
+
+void main()
+{
+  vec3 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec4-ivec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec4-ivec4.vert
new file mode 100644
index 00000000..c3e2a29e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec4-ivec4.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bvec4 a[2];
+
+void main()
+{
+  ivec4 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec4-vec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec4-vec4.vert
new file mode 100644
index 00000000..35e891be
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-bvec4-vec4.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform bvec4 a[2];
+
+void main()
+{
+  vec4 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-float-bool.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-float-bool.vert
new file mode 100644
index 00000000..028c8458
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-float-bool.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform float a[2];
+
+void main()
+{
+  bool b[2];
+  b = a;
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-float-int.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-float-int.vert
new file mode 100644
index 00000000..7a00b1a6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-float-int.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform float a[2];
+
+void main()
+{
+  int b[2];
+  b = a;
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-int-bool.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-int-bool.vert
new file mode 100644
index 00000000..5bbe87eb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-int-bool.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform int a[2];
+
+void main()
+{
+  bool b[2];
+  b = a;
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-int-float.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-int-float.vert
new file mode 100644
index 00000000..dfc4846e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-int-float.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform int a[2];
+
+void main()
+{
+  float b[2];
+  b = a;
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec2-bvec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec2-bvec2.vert
new file mode 100644
index 00000000..5483a5c6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec2-bvec2.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform ivec2 a[2];
+
+void main()
+{
+  bvec2 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec2-vec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec2-vec2.vert
new file mode 100644
index 00000000..93aaf4fc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec2-vec2.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform ivec2 a[2];
+
+void main()
+{
+  vec2 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec3-bvec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec3-bvec3.vert
new file mode 100644
index 00000000..a2816323
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec3-bvec3.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform ivec3 a[2];
+
+void main()
+{
+  bvec3 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec3-vec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec3-vec3.vert
new file mode 100644
index 00000000..7dfbcf94
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec3-vec3.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform ivec3 a[2];
+
+void main()
+{
+  vec3 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec4-bvec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec4-bvec4.vert
new file mode 100644
index 00000000..d5320891
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec4-bvec4.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform ivec4 a[2];
+
+void main()
+{
+  bvec4 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec4-vec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec4-vec4.vert
new file mode 100644
index 00000000..e05cefbf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-ivec4-vec4.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform ivec4 a[2];
+
+void main()
+{
+  vec4 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec2-bvec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec2-bvec2.vert
new file mode 100644
index 00000000..4123c104
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec2-bvec2.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform vec2 a[2];
+
+void main()
+{
+  bvec2 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec2-ivec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec2-ivec2.vert
new file mode 100644
index 00000000..b8e00e14
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec2-ivec2.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform vec2 a[2];
+
+void main()
+{
+  ivec2 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec3-bvec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec3-bvec3.vert
new file mode 100644
index 00000000..f4743515
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec3-bvec3.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform vec3 a[2];
+
+void main()
+{
+  bvec3 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec3-ivec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec3-ivec3.vert
new file mode 100644
index 00000000..34763c18
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec3-ivec3.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform vec3 a[2];
+
+void main()
+{
+  ivec3 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec4-bvec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec4-bvec4.vert
new file mode 100644
index 00000000..9f2248ac
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec4-bvec4.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  bvec4 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec4-ivec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec4-ivec4.vert
new file mode 100644
index 00000000..5fb50015
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-conversion-vec4-ivec4.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float."
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  ivec4 b[2];
+  b = a;
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-size.vert
new file mode 100644
index 00000000..b0f96886
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign-implicit-size.vert
@@ -0,0 +1,23 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "However, implicitly sized arrays cannot be assigned to.  Note, this is
+ *     a rare case that initializers and assignments appear to have different
+ *     semantics."
+ */
+
+
+uniform float a[5];
+
+void main()
+{
+	float b[];
+	b = a;
+
+	gl_Position = vec4(0);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign.vert
new file mode 100644
index 00000000..ea43f565
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-assign.vert
@@ -0,0 +1,30 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+void main()
+{
+  vec4 a[2];
+  vec4 b[2];
+  vec4 c[2];
+
+  a = vec4[2](vec4(0.0), vec4(2.0));
+  b = vec4[ ](vec4(0.5), vec4(2.0));
+  c = a;
+
+  gl_Position = a[0] + b[0] + c[1];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-attribute.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-attribute.vert
new file mode 100644
index 00000000..9e5adcd8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-attribute.vert
@@ -0,0 +1,19 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 23 (page 29 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Attribute variables cannot be declared as arrays or structures."
+ */
+
+
+attribute vec4 a[2]
+uniform int i;
+
+void main()
+{
+  gl_Position = a[i];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-implicit-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-implicit-size.vert
new file mode 100644
index 00000000..cb059a8d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-implicit-size.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an array is indexed with an expression that is not an integral
+ *     constant expression, or if an array is passed as an argument to a
+ *     function, then its size must be declared before any such use."
+ */
+
+
+/* Assume the array is sized in a different compilation unit.
+ */
+vec4 [] an_array;
+
+void main()
+{
+  gl_Position = an_array[2];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-negative.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-negative.vert
new file mode 100644
index 00000000..57adef39
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-negative.vert
@@ -0,0 +1,19 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "It is also illegal to index an array with a negative constant
+ *     expression."
+ */
+
+
+uniform vec4 [6] an_array;
+
+void main()
+{
+  gl_Position = an_array[-1];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-too-large.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-too-large.vert
new file mode 100644
index 00000000..edd6dd02
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-constant-index-too-large.vert
@@ -0,0 +1,20 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "It is illegal to declare an array with a size, and then later (in the
+ *     same shader) index the same array with an integral constant expression
+ *     greater than or equal to the declared size."
+ */
+
+
+uniform vec4 [6] an_array;
+
+void main()
+{
+  gl_Position = an_array[6];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bool-float.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bool-float.vert
new file mode 100644
index 00000000..b9897b04
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bool-float.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bool a[2];
+
+void main()
+{
+  float b[2] = float[](a[0], a[1]);
+
+  gl_Position = vec4(b[0]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bool-int.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bool-int.vert
new file mode 100644
index 00000000..6756e5df
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bool-int.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bool a[2];
+
+void main()
+{
+  int b[2] = int[](a[0], a[1]);
+
+  gl_Position = vec4(b[0]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec2-ivec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec2-ivec2.vert
new file mode 100644
index 00000000..e6acb50a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec2-ivec2.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bvec2 a[2];
+
+void main()
+{
+  ivec2 b[2] = ivec2[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec2-vec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec2-vec2.vert
new file mode 100644
index 00000000..8c7547af
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec2-vec2.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bvec2 a[2];
+
+void main()
+{
+  vec2 b[2] = vec2[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec3-ivec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec3-ivec3.vert
new file mode 100644
index 00000000..c35b80ca
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec3-ivec3.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bvec3 a[2];
+
+void main()
+{
+  ivec3 b[2] = ivec3[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec3-vec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec3-vec3.vert
new file mode 100644
index 00000000..f30cda7f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec3-vec3.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bvec3 a[2];
+
+void main()
+{
+  vec3 b[2] = vec3[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec4-ivec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec4-ivec4.vert
new file mode 100644
index 00000000..dca751bd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec4-ivec4.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bvec4 a[2];
+
+void main()
+{
+  ivec4 b[2] = ivec4[](a[0], a[1]);
+
+  gl_Position = vec4(b[0]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec4-vec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec4-vec4.vert
new file mode 100644
index 00000000..d518d646
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-bvec4-vec4.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform bvec4 a[2];
+
+void main()
+{
+  vec4 b[2] = vec4[](a[0], a[1]);
+
+  gl_Position = b[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-float-bool.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-float-bool.vert
new file mode 100644
index 00000000..908b60ea
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-float-bool.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform float a[2];
+
+void main()
+{
+  bool b[2] = bool[](a[0], a[0]);
+
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-float-int.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-float-int.vert
new file mode 100644
index 00000000..b1930b28
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-float-int.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform float a[2];
+
+void main()
+{
+  int b[2] = int[](a[0], a[0]);
+
+  gl_Position = vec4(b[0], b[0], b[1], b[1]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-int-bool.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-int-bool.vert
new file mode 100644
index 00000000..1431ea07
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-int-bool.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform int a[2];
+
+void main()
+{
+  bool b[2] = bool[](a[0], a[1]);
+
+  gl_Position = vec4(b[0]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-int-float.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-int-float.vert
new file mode 100644
index 00000000..be076126
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-int-float.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform int a[2];
+
+void main()
+{
+  float b[2] = float[](a[0], a[1]);
+
+  gl_Position = vec4(b[0]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec2-bvec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec2-bvec2.vert
new file mode 100644
index 00000000..cdb1b7be
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec2-bvec2.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform ivec2 a[2];
+
+void main()
+{
+  bvec2 b[2] = bvec2[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec2-vec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec2-vec2.vert
new file mode 100644
index 00000000..027577f3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec2-vec2.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform ivec2 a[2];
+
+void main()
+{
+  vec2 b[2] = vec2[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec3-bvec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec3-bvec3.vert
new file mode 100644
index 00000000..20fc85b6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec3-bvec3.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform ivec3 a[2];
+
+void main()
+{
+  bvec3 b[2] = bvec3[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec3-vec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec3-vec3.vert
new file mode 100644
index 00000000..0653d3c2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec3-vec3.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform ivec3 a[2];
+
+void main()
+{
+  vec3 b[2] = vec3[](a[0], a[1]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec4-bvec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec4-bvec4.vert
new file mode 100644
index 00000000..81a012ef
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec4-bvec4.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform ivec4 a[2];
+
+void main()
+{
+  bvec4 b[2] = bvec4[](a[0], a[1]);
+
+  gl_Position = vec4(b[0]);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec4-vec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec4-vec4.vert
new file mode 100644
index 00000000..a61446e2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-ivec4-vec4.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform ivec4 a[2];
+
+void main()
+{
+  vec4 b[2] = vec4[](a[0], a[1]);
+
+  gl_Position = b[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec2-bvec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec2-bvec2.vert
new file mode 100644
index 00000000..374b80bd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec2-bvec2.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform vec2 a[2];
+
+void main()
+{
+  bvec2 b[2] = bvec2[](a[0], a[0]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec2-ivec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec2-ivec2.vert
new file mode 100644
index 00000000..9d102d7a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec2-ivec2.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform vec2 a[2];
+
+void main()
+{
+  ivec2 b[2] = ivec2[](a[0], a[0]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec3-bvec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec3-bvec3.vert
new file mode 100644
index 00000000..991471d6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec3-bvec3.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform vec3 a[2];
+
+void main()
+{
+  bvec3 b[2] = bvec3[](a[0], a[0]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec3-ivec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec3-ivec3.vert
new file mode 100644
index 00000000..2a62ea71
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec3-ivec3.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform vec3 a[2];
+
+void main()
+{
+  ivec3 b[2] = ivec3[](a[0], a[0]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[1].x, b[1].y);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec4-bvec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec4-bvec4.vert
new file mode 100644
index 00000000..90efda56
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec4-bvec4.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  bvec4 b[2] = bvec4[](a[0], a[0]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[0].z, b[0].w);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec4-ivec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec4-ivec4.vert
new file mode 100644
index 00000000..513f9022
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-implicit-conversion-vec4-ivec4.vert
@@ -0,0 +1,37 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *     Type of expression   Can be implicitly converted to
+ *     int                  float
+ *     ivec2                vec2
+ *     ivec3                vec3
+ *     ivec4                vec4
+ *
+ *     There are no implicit array or structure conversions. For example, an
+ *     array of int cannot be implicitly converted to an array of float.  When
+ *     an implicit conversion is done, it is not just a re-interpretation of
+ *     the expression's value, but a conversion of that value to an equivalent
+ *     value in the new type. For example, the integer value 5 will be
+ *     converted to the floating-point value 5.0.  The conversions in the
+ *     table above are done only as indicated by other sections of this
+ *     specification."
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  ivec4 b[2] = ivec4[](a[0], a[0]);
+
+  gl_Position = vec4(b[0].x, b[0].y, b[0].z, b[0].w);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-mismatched-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-mismatched-size.vert
new file mode 100644
index 00000000..fd78eed7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor-mismatched-size.vert
@@ -0,0 +1,16 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 33 (page 39 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "There must be exactly the same number of arguments as the size of the
+ *     array being constructed."
+ */
+
+
+vec4 a[] = vec4[2](vec4(0.0), vec4(1.0), vec4(2.0));
+
+void main() { gl_Position = a[0]; }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor.vert
new file mode 100644
index 00000000..ec0ff82a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-ctor.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Arrays can have initializers formed from array constructors:"
+ */
+
+
+vec4 a[2] = vec4[2](vec4(0.0), vec4(2.0));
+vec4 b[2] = vec4[ ](vec4(0.5), vec4(2.0));
+vec4 c[ ] = vec4[ ](vec4(1.0), vec4(2.0));
+
+void main() { gl_Position = a[0] + b[0] + c[0]; }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-divide.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-divide.vert
new file mode 100644
index 00000000..14144c46
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-divide.vert
@@ -0,0 +1,26 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  vec4 c[2] = a / b;
+  gl_Position = c[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-implicit-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-implicit-size.vert
new file mode 100644
index 00000000..39b32e62
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-implicit-size.vert
@@ -0,0 +1,28 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  vec4 c[];
+
+  // Implicitly size c to match a and b.
+  c[0] = b[0];
+  c[1] = b[1];
+
+  gl_Position = vec4(a == c);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-matrix.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-matrix.vert
new file mode 100644
index 00000000..d1076632
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-matrix.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[4];
+uniform mat4 b;
+
+void main()
+{
+  gl_Position = vec4(a == b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-mismatched-base-type.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-mismatched-base-type.vert
new file mode 100644
index 00000000..214dcfa5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-mismatched-base-type.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec3 b[2]; // Note the differing base type
+
+void main()
+{
+  gl_Position = vec4(a == b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-mismatched-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-mismatched-size.vert
new file mode 100644
index 00000000..025de07c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-mismatched-size.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[3]; // Note the differing size
+
+void main()
+{
+  gl_Position = vec4(a == b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-vector.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-vector.vert
new file mode 100644
index 00000000..a9808810
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal-vector.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform float a[4];
+uniform vec4 b;
+
+void main()
+{
+  gl_Position = vec4(a == b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal.vert
new file mode 100644
index 00000000..a6ee2822
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-equal.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a == b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-parameter-implicit-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-parameter-implicit-size.vert
new file mode 100644
index 00000000..e9a065e2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-parameter-implicit-size.vert
@@ -0,0 +1,29 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an array is indexed with an expression that is not an integral
+ *     constant expression, or if an array is passed as an argument to a
+ *     function, then its size must be declared before any such use."
+ */
+
+
+float a_function(vec4[6]);
+
+void main()
+{
+  vec4 [] an_array;
+
+  an_array[0] = vec4(0);
+  an_array[1] = vec4(1);
+  an_array[2] = vec4(2);
+  an_array[3] = vec4(3);
+  an_array[4] = vec4(4);
+  an_array[5] = vec4(5);
+
+  gl_Position = vec4(a_function(an_array));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-parameter-unsized.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-parameter-unsized.vert
new file mode 100644
index 00000000..b8135ca7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-parameter-unsized.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Arrays declared as formal parameters in a function declaration
+ *     must specify a size."
+ */
+
+
+vec4 a_function(vec4 [] p);
+
+uniform vec4 [6] an_array;
+
+void main()
+{
+  gl_Position = a_function(an_array);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-return-unsized.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-return-unsized.vert
new file mode 100644
index 00000000..9acba275
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-return-unsized.vert
@@ -0,0 +1,31 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "This type can be used anywhere any other type can be used, including
+ *     as the return value from a function
+ *
+ *         float[5] foo() { }
+ *
+ *     as a constructor of an array
+ *
+ *         float[5](3.4, 4.2, 5.0, 5.2, 1.1)
+ *
+ *     as an unnamed parameter
+ *
+ *         void foo(float[5])"
+ */
+
+
+vec4[] a_function(vec4 [6] p);
+
+uniform vec4 [6] an_array;
+
+void main()
+{
+  gl_Position = a_function(an_array)[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-return.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-return.vert
new file mode 100644
index 00000000..cc58f9fb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-function-return.vert
@@ -0,0 +1,31 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "This type can be used anywhere any other type can be used, including
+ *     as the return value from a function
+ *
+ *         float[5] foo() { }
+ *
+ *     as a constructor of an array
+ *
+ *         float[5](3.4, 4.2, 5.0, 5.2, 1.1)
+ *
+ *     as an unnamed parameter
+ *
+ *         void foo(float[5])"
+ */
+
+
+vec4[2] a_function(vec4 [6]);
+
+uniform vec4 [6] an_array;
+
+void main()
+{
+  gl_Position = a_function(an_array)[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-greater-equal.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-greater-equal.vert
new file mode 100644
index 00000000..464208cc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-greater-equal.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a >= b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-greater.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-greater.vert
new file mode 100644
index 00000000..fbc3019d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-greater.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a > b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length-implicit-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length-implicit-size.vert
new file mode 100644
index 00000000..b5bafa75
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length-implicit-size.vert
@@ -0,0 +1,21 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The length method cannot be called on an array that has not been
+ *     explicitly sized."
+ */
+
+
+void main()
+{
+	float b[];
+
+	b[2] = 1.0;  // Implicitly size array to have at least 3 elements
+
+	gl_Position = vec4(b.length());
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length-with-argument.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length-with-argument.vert
new file mode 100644
index 00000000..2096ae5c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length-with-argument.vert
@@ -0,0 +1,14 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  gl_Position = vec4(a.length(5));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length.vert
new file mode 100644
index 00000000..3399b199
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-length.vert
@@ -0,0 +1,24 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Arrays know the number of elements they contain. This can be obtained
+ *     by using the length method:
+ *
+ *         a.length(); // returns 5 for the above declarations
+ *
+ *     The length method cannot be called on an array that has not been
+ *     explicitly sized."
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  gl_Position = vec4(a.length());
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-less-equal.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-less-equal.vert
new file mode 100644
index 00000000..803d539f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-less-equal.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a <= b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-less.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-less.vert
new file mode 100644
index 00000000..2f54c746
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-less.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a < b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-and.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-and.vert
new file mode 100644
index 00000000..f14211a9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-and.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a && b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-not.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-not.vert
new file mode 100644
index 00000000..85800965
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-not.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(!a);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-or.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-or.vert
new file mode 100644
index 00000000..fd22520a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-or.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a || b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-xor.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-xor.vert
new file mode 100644
index 00000000..64ebe544
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-logical-xor.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a ^^ b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multidimensional-new-syntax.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multidimensional-new-syntax.vert
new file mode 100644
index 00000000..7e113883
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multidimensional-new-syntax.vert
@@ -0,0 +1,18 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+uniform vec4 [1] an_array[1];
+
+void main()
+{
+  gl_Position = an_array[0][0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multidimensional.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multidimensional.vert
new file mode 100644
index 00000000..984d29c9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multidimensional.vert
@@ -0,0 +1,18 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+uniform vec4 an_array[1][1];
+
+void main()
+{
+  gl_Position = an_array[0][0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multiply.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multiply.vert
new file mode 100644
index 00000000..1c33f777
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-multiply.vert
@@ -0,0 +1,26 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  vec4 c[2] = a * b;
+  gl_Position = c[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-negate.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-negate.vert
new file mode 100644
index 00000000..567b3d35
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-negate.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(-a == b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-implicit-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-implicit-size.vert
new file mode 100644
index 00000000..4f522e36
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-implicit-size.vert
@@ -0,0 +1,28 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  vec4 c[];
+
+  // Implicitly size c to match a and b.
+  c[0] = b[0];
+  c[1] = b[2];
+
+  gl_Position = vec4(a != c);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-matrix.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-matrix.vert
new file mode 100644
index 00000000..88bda2ae
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-matrix.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[4];
+uniform mat4 b;
+
+void main()
+{
+  gl_Position = vec4(a != b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-mismatched-base-type.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-mismatched-base-type.vert
new file mode 100644
index 00000000..fb771112
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-mismatched-base-type.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec3 b[2]; // Note the differing base type
+
+void main()
+{
+  gl_Position = vec4(a != b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-mismatched-size.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-mismatched-size.vert
new file mode 100644
index 00000000..b709902e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-mismatched-size.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[3]; // Note the differing size
+
+void main()
+{
+  gl_Position = vec4(a != b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-vertor.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-vertor.vert
new file mode 100644
index 00000000..e7a3f07f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal-vertor.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform float a[4];
+uniform vec4 b;
+
+void main()
+{
+  gl_Position = vec4(a != b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal.vert
new file mode 100644
index 00000000..2e57da5e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-not-equal.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The equality operators and assignment operator are only allowed if the
+ *     two operands are same size and type....Both array operands must be
+ *     explicitly sized. When using the equality operators ... two arrays are
+ *     equal if and only if all the elements are element-wise equal.
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(a != b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-any-type.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-any-type.vert
new file mode 100644
index 00000000..4b16a87a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-any-type.vert
@@ -0,0 +1,44 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "All basic types and structures can be formed into arrays."
+ */
+
+
+uniform float array01[1];
+uniform int array02[1];
+uniform bool array03[1];
+uniform vec2 array04[1];
+uniform vec3 array05[1];
+uniform vec4 array06[1];
+uniform ivec2 array07[1];
+uniform ivec3 array08[1];
+uniform ivec4 array09[1];
+uniform bvec2 array10[1];
+uniform bvec3 array11[1];
+uniform bvec4 array12[1];
+uniform mat2 array13[1];
+uniform mat2x2 array14[1];
+uniform mat2x3 array15[1];
+uniform mat2x4 array16[1];
+uniform mat3 array17[1];
+uniform mat3x2 array18[1];
+uniform mat3x3 array19[1];
+uniform mat3x4 array20[1];
+uniform mat4 array21[1];
+uniform mat4x2 array22[1];
+uniform mat4x3 array23[1];
+uniform mat4x4 array24[1];
+uniform sampler1D array25[1];
+uniform sampler2D array26[1];
+uniform sampler3D array27[1];
+uniform samplerCube array28[1];
+uniform sampler1DShadow array29[1];
+uniform sampler2DShadow array30[1];
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-declaration.frag b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-declaration.frag
new file mode 100644
index 00000000..b911f730
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-declaration.frag
@@ -0,0 +1,20 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+attribute vec4 vert;
+
+void foo(vec4 [2] x[2]);
+
+void main()
+{
+  gl_FragData[0] = vec4(0.0);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-declaration.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-declaration.vert
new file mode 100644
index 00000000..b32216cd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-declaration.vert
@@ -0,0 +1,20 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+attribute vec4 vert;
+
+void foo(vec4 [2] x[2]);
+
+void main()
+{
+  gl_Position = vert;
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-definition.frag b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-definition.frag
new file mode 100644
index 00000000..cc07075b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-definition.frag
@@ -0,0 +1,23 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+attribute vec4 vert;
+
+void foo(vec4 [2] x[2])
+{
+  gl_Position = vert;
+}
+
+void main()
+{
+  gl_FragData[0] = vec4(0.0);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-definition.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-definition.vert
new file mode 100644
index 00000000..6c12fda1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-function-parameter-definition.vert
@@ -0,0 +1,23 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+attribute vec4 vert;
+
+void foo(vec4 [2] x[2])
+{
+  gl_Position = vert;
+}
+
+void main()
+{
+  gl_Position = vert;
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-structure-field.frag b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-structure-field.frag
new file mode 100644
index 00000000..6eb9aebc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-structure-field.frag
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+attribute vec4 vert;
+
+struct S {
+  vec4 [2] x[2];
+};
+
+void main()
+{
+  gl_FragData[0] = vec4(0.0);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-structure-field.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-structure-field.vert
new file mode 100644
index 00000000..9b884f50
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-array-structure-field.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Only one-dimensional arrays may be declared."
+ */
+
+
+attribute vec4 vert;
+
+struct S {
+  vec4 [2] x[2];
+};
+
+void main()
+{
+  gl_Position = vert;
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-struct-of-array.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-struct-of-array.vert
new file mode 100644
index 00000000..1bf190d2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-struct-of-array.vert
@@ -0,0 +1,28 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 18 (page 24 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "Member declarators can contain arrays.  Such arrays must have a size
+ *     specified, and the size must be an integral constant expression that's
+ *     greater than zero (see Section 4.3.3 "Constant Expressions")."
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "All basic types and structures can be formed into arrays."
+ */
+
+
+struct s {
+  float x[3];
+  int y;
+};
+
+void main()
+{
+  s a[2];
+  gl_Position = vec4(a.length() + a.x.length());
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-struct.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-struct.vert
new file mode 100644
index 00000000..077f18cd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-of-struct.vert
@@ -0,0 +1,22 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "All basic types and structures can be formed into arrays."
+ */
+
+
+struct s {
+  float x;
+  int y;
+};
+
+void main()
+{
+  s a[2];
+  gl_Position = vec4(a.length());
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-positive.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-positive.vert
new file mode 100644
index 00000000..b1ff7e4e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-positive.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = vec4(+a == b);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-postdecrement.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-postdecrement.vert
new file mode 100644
index 00000000..37b9ac6f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-postdecrement.vert
@@ -0,0 +1,24 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  gl_Position = (a--)[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-postincrement.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-postincrement.vert
new file mode 100644
index 00000000..16d096ad
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-postincrement.vert
@@ -0,0 +1,24 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  gl_Position = (a++)[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-predecrement.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-predecrement.vert
new file mode 100644
index 00000000..c9e221f4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-predecrement.vert
@@ -0,0 +1,24 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  gl_Position = (--a)[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-preincrement.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-preincrement.vert
new file mode 100644
index 00000000..dba841e1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-preincrement.vert
@@ -0,0 +1,24 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+
+void main()
+{
+  gl_Position = (++a)[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-01.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-01.vert
new file mode 100644
index 00000000..1bc0ebff
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-01.vert
@@ -0,0 +1,31 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "It is legal to declare an array without a size and then later
+ *     re-declare the same name as an array of the same type and specify a
+ *     size."
+ */
+
+
+float a_function(vec4[6]);
+
+void main()
+{
+  vec4 [] an_array;
+
+  an_array[0] = vec4(0);
+  an_array[1] = vec4(1);
+  an_array[2] = vec4(2);
+  an_array[3] = vec4(3);
+  an_array[4] = vec4(4);
+  an_array[5] = vec4(5);
+
+  vec4 [6] an_array;
+
+  gl_Position = vec4(a_function(an_array));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-initializer.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-initializer.vert
new file mode 100644
index 00000000..d0b86dcd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-initializer.vert
@@ -0,0 +1,28 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "It is legal to declare an array without a size and then later
+ *     re-declare the same name as an array of the same type and specify a
+ *     size."
+ */
+
+
+float a_function(float[3]);
+
+void main()
+{
+  float [] an_array;
+
+  an_array[0] = 0.0;
+  an_array[1] = 1.0;
+  an_array[2] = 2.0;
+
+  float [] an_array = float[](2.0, 1.0, 0.0);
+
+  gl_Position = vec4(a_function(an_array));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-too-small.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-too-small.vert
new file mode 100644
index 00000000..970a250c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-too-small.vert
@@ -0,0 +1,28 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "It is legal to declare an array without a size and then later
+ *     re-declare the same name as an array of the same type and specify a
+ *     size."
+ */
+
+
+float a_function(float[2]);
+
+void main()
+{
+  float [] an_array;
+
+  an_array[0] = 0.0;
+  an_array[1] = 1.0;
+  an_array[2] = 2.0;
+
+  float [2] an_array;
+
+  gl_Position = vec4(a_function(an_array));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-wrong-base-type.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-wrong-base-type.vert
new file mode 100644
index 00000000..2998e4d2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-redeclaration-wrong-base-type.vert
@@ -0,0 +1,29 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "It is legal to declare an array without a size and then later
+ *     re-declare the same name as an array of the same type and specify a
+ *     size."
+ */
+
+
+float a_function(float[3]);
+float a_function(vec4[3]);
+
+void main()
+{
+  float [] an_array;
+
+  an_array[0] = 0.0;
+  an_array[1] = 1.0;
+  an_array[2] = 2.0;
+
+  vec4 [3] an_array;
+
+  gl_Position = vec4(a_function(an_array));
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-selection.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-selection.vert
new file mode 100644
index 00000000..dc3fe359
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-selection.vert
@@ -0,0 +1,24 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 38 (page 44 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The ternary selection operator (?:). It operates on three expressions
+ *     (exp1 ? exp2 : exp3)....The second and third expressions can be any
+ *     type, as long their types match....This resulting matching type is
+ *     the type of the entire expression."
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+uniform int i;
+uniform bool pick_from_a_or_b;
+
+void main()
+{
+  gl_Position = (pick_from_a_or_b ? a : b)[i];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-sequence.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-sequence.vert
new file mode 100644
index 00000000..bf6a96d5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-sequence.vert
@@ -0,0 +1,25 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  gl_Position = (a, b)[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-shadow-redeclaration.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-shadow-redeclaration.vert
new file mode 100644
index 00000000..f691fd8d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-shadow-redeclaration.vert
@@ -0,0 +1,29 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 21 (page 27 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "An implicitly sized array can be re-declared in the same scope
+ *     as an array of the same base type."
+ */
+
+
+attribute vec4 v;
+
+void main()
+{
+  float a[];
+
+  a[3] = 1.2;   // Implicitly size "a" to have 4 elements.
+
+  {
+    float a[4]; // this declaration shadows the previous
+  }
+
+  a.length();   // illegal - "a' is not explicitly sized
+
+  gl_Position = v;
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bool.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bool.vert
new file mode 100644
index 00000000..223ae49c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bool.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [true] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec2.vert
new file mode 100644
index 00000000..bff5c946
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec2.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [bvec2(true, false)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec3.vert
new file mode 100644
index 00000000..b17b2975
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec3.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [bvec3(true, true, false)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec4.vert
new file mode 100644
index 00000000..00d28447
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec4.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [bvec4(true, true, false, false)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-cast.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-cast.vert
new file mode 100644
index 00000000..8a9324a6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-cast.vert
@@ -0,0 +1,18 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+const float size = 3.14159;
+uniform vec4 [int(size)] a;
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-relational.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-relational.vert
new file mode 100644
index 00000000..2fca80b8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-relational.vert
@@ -0,0 +1,162 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+const vec4 v4_1 = vec4(1);
+const vec4 v4_0 = v4_1 - v4_1;
+const vec3 v3_1 = vec3(1);
+const vec3 v3_0 = v3_1 - v3_1;
+const vec2 v2_1 = vec2(1);
+const vec2 v2_0 = v2_1 - v2_1;
+
+const ivec4 iv4_1 = ivec4(1);
+const ivec4 iv4_0 = iv4_1 - iv4_1;
+const ivec3 iv3_1 = ivec3(1);
+const ivec3 iv3_0 = iv3_1 - iv3_1;
+const ivec2 iv2_1 = ivec2(1);
+const ivec2 iv2_0 = iv2_1 - iv2_1;
+
+const bvec4 bv4_1 = bvec4(true);
+const bvec4 bv4_0 = not(bv4_1);
+const bvec3 bv3_1 = bvec3(true);
+const bvec3 bv3_0 = not(bv3_1);
+const bvec2 bv2_1 = bvec2(true);
+const bvec2 bv2_0 = not(bv2_1);
+
+// All forms of lessThan.
+float [all(    lessThan( v4_1,  v4_0) ) ? -1 :  1] array01;
+float [all(not(lessThan( v4_1,  v4_0))) ?  1 : -1] array02;
+float [any(    lessThan( v4_1,  v4_0) ) ? -1 :  1] array03;
+float [any(not(lessThan( v4_1,  v4_0))) ?  1 : -1] array04;
+float [all(    lessThan(iv4_1, iv4_0) ) ? -1 :  1] array05;
+float [all(not(lessThan(iv4_1, iv4_0))) ?  1 : -1] array06;
+float [any(    lessThan(iv4_1, iv4_0) ) ? -1 :  1] array07;
+float [any(not(lessThan(iv4_1, iv4_0))) ?  1 : -1] array08;
+
+// All forms of lessThanEqual.
+float [all(    lessThanEqual( v4_1,  v4_0) ) ? -1 :  1] array11;
+float [all(not(lessThanEqual( v4_1,  v4_0))) ?  1 : -1] array12;
+float [any(    lessThanEqual( v4_1,  v4_0) ) ? -1 :  1] array13;
+float [any(not(lessThanEqual( v4_1,  v4_0))) ?  1 : -1] array14;
+float [all(    lessThanEqual(iv4_1, iv4_0) ) ? -1 :  1] array15;
+float [all(not(lessThanEqual(iv4_1, iv4_0))) ?  1 : -1] array16;
+float [any(    lessThanEqual(iv4_1, iv4_0) ) ? -1 :  1] array17;
+float [any(not(lessThanEqual(iv4_1, iv4_0))) ?  1 : -1] array18;
+
+// All forms of greaterThan.
+float [all(    greaterThan( v4_1,  v4_0) ) ?  1 : -1] array21;
+float [all(not(greaterThan( v4_1,  v4_0))) ? -1 :  1] array22;
+float [any(    greaterThan( v4_1,  v4_0) ) ?  1 : -1] array23;
+float [any(not(greaterThan( v4_1,  v4_0))) ? -1 :  1] array24;
+float [all(    greaterThan(iv4_1, iv4_0) ) ?  1 : -1] array25;
+float [all(not(greaterThan(iv4_1, iv4_0))) ? -1 :  1] array26;
+float [any(    greaterThan(iv4_1, iv4_0) ) ?  1 : -1] array27;
+float [any(not(greaterThan(iv4_1, iv4_0))) ? -1 :  1] array28;
+
+// All forms of greaterThanEqual.
+float [all(    greaterThanEqual( v4_1,  v4_0) ) ?  1 : -1] array31;
+float [all(not(greaterThanEqual( v4_1,  v4_0))) ? -1 :  1] array32;
+float [any(    greaterThanEqual( v4_1,  v4_0) ) ?  1 : -1] array33;
+float [any(not(greaterThanEqual( v4_1,  v4_0))) ? -1 :  1] array34;
+float [all(    greaterThanEqual(iv4_1, iv4_0) ) ?  1 : -1] array35;
+float [all(not(greaterThanEqual(iv4_1, iv4_0))) ? -1 :  1] array36;
+float [any(    greaterThanEqual(iv4_1, iv4_0) ) ?  1 : -1] array37;
+float [any(not(greaterThanEqual(iv4_1, iv4_0))) ? -1 :  1] array38;
+
+// All forms of equal.
+float [all(    equal( v4_1,  v4_0) ) ? -1 :  1] array41;
+float [all(not(equal( v4_1,  v4_0))) ?  1 : -1] array42;
+float [any(    equal( v4_1,  v4_0) ) ? -1 :  1] array43;
+float [any(not(equal( v4_1,  v4_0))) ?  1 : -1] array44;
+float [all(    equal(iv4_1, iv4_0) ) ? -1 :  1] array45;
+float [all(not(equal(iv4_1, iv4_0))) ?  1 : -1] array46;
+float [any(    equal(iv4_1, iv4_0) ) ? -1 :  1] array47;
+float [any(not(equal(iv4_1, iv4_0))) ?  1 : -1] array48;
+float [all(    equal(bv4_1, bv4_0) ) ? -1 :  1] array49;
+float [all(not(equal(bv4_1, bv4_0))) ?  1 : -1] array4a;
+float [any(    equal(bv4_1, bv4_0) ) ? -1 :  1] array4b;
+float [any(not(equal(bv4_1, bv4_0))) ?  1 : -1] array4c;
+
+// All forms of notEqual.
+float [all(    notEqual( v4_1,  v4_0) ) ?  1 : -1] array51;
+float [all(not(notEqual( v4_1,  v4_0))) ? -1 :  1] array52;
+float [any(    notEqual( v4_1,  v4_0) ) ?  1 : -1] array53;
+float [any(not(notEqual( v4_1,  v4_0))) ? -1 :  1] array54;
+float [all(    notEqual(iv4_1, iv4_0) ) ?  1 : -1] array55;
+float [all(not(notEqual(iv4_1, iv4_0))) ? -1 :  1] array56;
+float [any(    notEqual(iv4_1, iv4_0) ) ?  1 : -1] array57;
+float [any(not(notEqual(iv4_1, iv4_0))) ? -1 :  1] array58;
+float [all(    notEqual(bv4_1, bv4_0) ) ?  1 : -1] array59;
+float [all(not(notEqual(bv4_1, bv4_0))) ? -1 :  1] array5a;
+float [any(    notEqual(bv4_1, bv4_0) ) ?  1 : -1] array5b;
+float [any(not(notEqual(bv4_1, bv4_0))) ? -1 :  1] array5c;
+
+void main()
+{
+  gl_Position = vec4(array01.length()
+		     + array02.length()
+		     + array03.length()
+		     + array04.length()
+		     + array05.length()
+		     + array06.length()
+		     + array07.length()
+		     + array08.length()
+		     + array11.length()
+		     + array12.length()
+		     + array13.length()
+		     + array14.length()
+		     + array15.length()
+		     + array16.length()
+		     + array17.length()
+		     + array18.length()
+		     + array21.length()
+		     + array22.length()
+		     + array23.length()
+		     + array24.length()
+		     + array25.length()
+		     + array26.length()
+		     + array27.length()
+		     + array28.length()
+		     + array31.length()
+		     + array32.length()
+		     + array33.length()
+		     + array34.length()
+		     + array35.length()
+		     + array36.length()
+		     + array37.length()
+		     + array38.length()
+		     + array41.length()
+		     + array42.length()
+		     + array43.length()
+		     + array44.length()
+		     + array45.length()
+		     + array46.length()
+		     + array47.length()
+		     + array48.length()
+		     + array49.length()
+		     + array4a.length()
+		     + array4b.length()
+		     + array4c.length()
+		     + array51.length()
+		     + array52.length()
+		     + array53.length()
+		     + array54.length()
+		     + array55.length()
+		     + array56.length()
+		     + array57.length()
+		     + array58.length()
+		     + array59.length()
+		     + array5a.length()
+		     + array5b.length()
+		     + array5c.length());
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-float.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-float.vert
new file mode 100644
index 00000000..94a121f2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-float.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [2.3] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-int.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-int.vert
new file mode 100644
index 00000000..592c353d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-int.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [int(2.3)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec2.vert
new file mode 100644
index 00000000..d88e47d7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec2.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [ivec2(2.3,2.3)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec3.vert
new file mode 100644
index 00000000..5bdaaf71
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec3.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [ivec3(2.3,2.3,2.3)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec4.vert
new file mode 100644
index 00000000..1a1a6ea9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec4.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [ivec4(2.3,2.3,2.3,2.3)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-length.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-length.vert
new file mode 100644
index 00000000..f78465d8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-length.vert
@@ -0,0 +1,18 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform vec4 [3] a;
+uniform vec4 [a.length()] b;
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-negative.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-negative.vert
new file mode 100644
index 00000000..bd17dacb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-negative.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform vec4 [-1] a;
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-non-builtin-function.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-non-builtin-function.vert
new file mode 100644
index 00000000..99b7e1ba
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-non-builtin-function.vert
@@ -0,0 +1,19 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+int foo() { return 3; }
+
+uniform vec4 [foo()] a;
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-not-constant.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-not-constant.vert
new file mode 100644
index 00000000..baa377eb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-not-constant.vert
@@ -0,0 +1,18 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform int size;
+uniform vec4 [size] a;
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-selection.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-selection.vert
new file mode 100644
index 00000000..4ecc2c33
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-selection.vert
@@ -0,0 +1,23 @@
+/* [config]
+ * expect_result: pass
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 38 (page 44 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "The ternary selection operator (?:). It operates on three expressions
+ *     (exp1 ? exp2 : exp3)....The second and third expressions can be any
+ *     type, as long their types match....This resulting matching type is
+ *     the type of the entire expression."
+ */
+
+
+const vec4[] a = vec4[](vec4(0), vec4(1));
+const vec4[] b = vec4[](vec4(1), vec4(0));
+uniform vec4 c[((true) ? a : b).length()];
+
+void main()
+{
+  gl_Position = c[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence-in-parenthesis.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence-in-parenthesis.vert
new file mode 100644
index 00000000..0f0b5789
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence-in-parenthesis.vert
@@ -0,0 +1,33 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * The body of the GLSL spec is slient on this issue, but the grammar says:
+ *
+ *     expression:
+ *         assignment_expression
+ *         expression COMMA assignment_expression
+ *
+ *     constant_expression:
+ *         conditional_expression
+ *
+ *     ...
+ *
+ *     init_declarator_list:
+ *         single_declaration
+ *         init_declarator_list COMMA IDENTIFIER
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET RIGHT_BRACKET
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET RIGHT_BRACKET EQUAL initializer
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET EQUAL initializer
+ *         init_declarator_list COMMA IDENTIFIER EQUAL initializer
+ *
+ * This also matches C and C++.
+ */
+
+
+uniform float a[(5,3)];
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence.vert
new file mode 100644
index 00000000..387161fb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence.vert
@@ -0,0 +1,33 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * The body of the GLSL spec is slient on this issue, but the grammar says:
+ *
+ *     expression:
+ *         assignment_expression
+ *         expression COMMA assignment_expression
+ *
+ *     constant_expression:
+ *         conditional_expression
+ *
+ *     ...
+ *
+ *     init_declarator_list:
+ *         single_declaration
+ *         init_declarator_list COMMA IDENTIFIER
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET RIGHT_BRACKET
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET RIGHT_BRACKET EQUAL initializer
+ *         init_declarator_list COMMA IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET EQUAL initializer
+ *         init_declarator_list COMMA IDENTIFIER EQUAL initializer
+ *
+ * This also matches C and C++.
+ */
+
+
+uniform float a[5,3];
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec2.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec2.vert
new file mode 100644
index 00000000..3712d4ee
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec2.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [vec2(2,2)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec3.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec3.vert
new file mode 100644
index 00000000..7817ea00
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec3.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [vec3(2,2,2)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec4.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec4.vert
new file mode 100644
index 00000000..39edae0c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec4.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform float [vec4(2,2,2,2)] a;
+
+void main() { gl_Position = vec4(a[0]); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-with-side-effect.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-with-side-effect.vert
new file mode 100644
index 00000000..426e3a63
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-with-side-effect.vert
@@ -0,0 +1,20 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+void main()
+{
+  int x;
+  vec4[(x = 3)] a;
+  gl_Position = vec4(0.0);
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-zero.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-zero.vert
new file mode 100644
index 00000000..547d4c14
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-zero.vert
@@ -0,0 +1,17 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "When an array size is specified in a declaration, it must be an
+ *     integral constant expression (see Section 4.3.3 "Constant Expressions")
+ *     greater than zero."
+ */
+
+
+uniform vec4 [0] a;
+
+void main() { gl_Position = vec4(0.0); }
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-subtract.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-subtract.vert
new file mode 100644
index 00000000..776325a1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-subtract.vert
@@ -0,0 +1,26 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 35 (page 41 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In total, only the following operators are allowed to operate on
+ *     arrays and structures as whole entities:
+ *
+ *     field or method selector .
+ *     equality                 == !=
+ *     assignment               =
+ *     indexing (arrays only)   []"
+ */
+
+
+uniform vec4 a[2];
+uniform vec4 b[2];
+
+void main()
+{
+  vec4 c[2] = a - b;
+  gl_Position = c[0];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-variable-index-implicit-size-global.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-variable-index-implicit-size-global.vert
new file mode 100644
index 00000000..e4527b16
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-variable-index-implicit-size-global.vert
@@ -0,0 +1,24 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an array is indexed with an expression that is not an integral
+ *     constant expression, or if an array is passed as an argument to a
+ *     function, then its size must be declared before any such use."
+ */
+
+
+/* Assume the array is sized in a different compilation unit.
+ */
+vec4 [] an_array;
+
+uniform int i;
+
+void main()
+{
+  gl_Position = an_array[i];
+}
diff --git a/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-variable-index-implicit-size-local.vert b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-variable-index-implicit-size-local.vert
new file mode 100644
index 00000000..2269c49e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-variable-index-implicit-size-local.vert
@@ -0,0 +1,29 @@
+/* [config]
+ * expect_result: fail
+ * glsl_version: 1.20
+ * glsles_version: 1.00
+ * [end config]
+ *
+ * From page 19 (page 25 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an array is indexed with an expression that is not an integral
+ *     constant expression, or if an array is passed as an argument to a
+ *     function, then its size must be declared before any such use."
+ */
+
+
+attribute vec4 a;
+attribute vec4 b;
+
+uniform int i;
+
+void main()
+{
+  vec4 [] an_array;
+
+  an_array[0] = a;
+  an_array[1] = vec4(0);
+  an_array[2] = b;
+
+  gl_Position = an_array[i];
+}
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/clipping.out b/tests/spec/glsl-es-1.00/execution/1.20/clipping/clipping.out
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/clipping.out
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/fixed-clip-enables.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/clipping/fixed-clip-enables.shader_test
new file mode 100644
index 00000000..93995a5c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/fixed-clip-enables.shader_test
@@ -0,0 +1,141 @@
+# This test reproduces bug 41603
+# (https://bugs.freedesktop.org/show_bug.cgi?id=41603).
+#
+# This test sets up 6 clipping planes using fixed vertex
+# functionality, which clip a rectangle to a hexagon shape.  Then it
+# tests various combinations of enables for the 6 clipping planes, and
+# verifies that they all create the correct shape.
+#
+# To verify that each enable works, the combinations of enables were
+# chosen such that:
+# - Every plane is enabled at least once and disbled at least once.
+# - Every plane is enabled and disabled in a different pattern.
+#
+# Note: Some implementations have bugs related to improper coordinate
+# transformations of clip planes (which are already adequately tested
+# by the clip-plane-transformation test), so to avoid those bugs
+# contaminating the results of this test, we don't do any coordinate
+# transformation in this test.
+
+[require]
+GLSL >= 1.20
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	gl_FragColor = vec4(1, 1, 1, 1);
+}
+
+[test]
+clip plane 0 0 1 0 0.5
+clip plane 1 -1 1 0 0.8
+clip plane 2 -1 -1 0 0.8
+clip plane 3 0 -1 0 0.5
+clip plane 4 1 -1 0 0.8
+clip plane 5 1 1 0 0.8
+clear color 0.0 0.0 0.0 0.0
+
+# Test with planes 0, 2, and 4 enabled.
+enable GL_CLIP_PLANE0
+disable GL_CLIP_PLANE1
+enable GL_CLIP_PLANE2
+disable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+disable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (1.0, 1.0, 1.0, 1.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 5
+
+# Test with planes 0, 1, 4, and 5 enabled.
+enable GL_CLIP_PLANE0
+enable GL_CLIP_PLANE1
+disable GL_CLIP_PLANE2
+disable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+enable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (1.0, 1.0, 1.0, 1.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (1.0, 1.0, 1.0, 1.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 5
+
+# Test with planes 0, 1, 2, and 3 enabled.
+enable GL_CLIP_PLANE0
+enable GL_CLIP_PLANE1
+enable GL_CLIP_PLANE2
+enable GL_CLIP_PLANE3
+disable GL_CLIP_PLANE4
+disable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (0.0, 0.0, 0.0, 0.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (1.0, 1.0, 1.0, 1.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 5
+
+# Test with planes 4 and 5 enabled.
+disable GL_CLIP_PLANE0
+disable GL_CLIP_PLANE1
+disable GL_CLIP_PLANE2
+disable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+enable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (1.0, 1.0, 1.0, 1.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (1.0, 1.0, 1.0, 1.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (1.0, 1.0, 1.0, 1.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 5
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-const-accept.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-const-accept.shader_test
new file mode 100644
index 00000000..6c2b56cf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-const-accept.shader_test
@@ -0,0 +1,42 @@
+# From the GL 2.1 spec, section 2.17 (Clipping):
+#
+#   All points with eye coordinates (x_e y_e z_e w_e)^T that satisfy
+#
+#                          (x_e)
+#     (p_1' p_2' p_3' p_4')(y_e) >= 0
+#                          (z_e)
+#                          (w_e)
+#
+#   lie in the half-space defined by the plane; points that do not
+#   satisfy this condition do not lie in the half-space.
+#
+# This test checks that gl_ClipVertex works properly for the trivial
+# case where gl_ClipVertex is a constant value satisfying the above
+# inequality.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+	gl_ClipVertex = vec4(1.0, 0.0, 0.0, 0.0);
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	gl_FragColor = vec4(1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+clip plane 0 1.0 0.0 0.0 0.0 # accept points where gl_ClipVertex.x >= 0
+enable GL_CLIP_PLANE0
+draw rect -1 -1 2 2
+probe all rgba 1.0 1.0 1.0 1.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-const-reject.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-const-reject.shader_test
new file mode 100644
index 00000000..0bb08ea0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-const-reject.shader_test
@@ -0,0 +1,42 @@
+# From the GL 2.1 spec, section 2.17 (Clipping):
+#
+#   All points with eye coordinates (x_e y_e z_e w_e)^T that satisfy
+#
+#                          (x_e)
+#     (p_1' p_2' p_3' p_4')(y_e) >= 0
+#                          (z_e)
+#                          (w_e)
+#
+#   lie in the half-space defined by the plane; points that do not
+#   satisfy this condition do not lie in the half-space.
+#
+# This test checks that gl_ClipVertex works properly for the trivial
+# case where gl_ClipVertex is a constant value not satisfying the
+# above inequality.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+	gl_ClipVertex = vec4(-1.0, 0.0, 0.0, 0.0);
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	gl_FragColor = vec4(1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+clip plane 0 1.0 0.0 0.0 0.0 # accept points where gl_ClipVertex.x >= 0
+enable GL_CLIP_PLANE0
+draw rect -1 -1 2 2
+probe all rgba 0.0 0.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-different-from-position.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-different-from-position.shader_test
new file mode 100644
index 00000000..c7dae897
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-different-from-position.shader_test
@@ -0,0 +1,62 @@
+# [description]
+# Use all 6 clip planes to clip a rectangle to a hexagon shape.
+#
+# In this test, gl_Position and gl_ClipVertex are different to verify
+# that gl_Position determines screen position and gl_ClipVertex
+# determines clipping.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+	// Transform gl_ClipVertex in an arbitrary way so that
+	// we can verify it is being used for clipping instead of
+	// gl_Position.
+	gl_ClipVertex = gl_Vertex * vec4(10.0, 10.0, 1.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	gl_FragColor = vec4(1, 1, 1, 1);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho 0 1 0 1
+clip plane 0 0 1 0 -2.5
+clip plane 1 -1 1 0 4
+clip plane 2 -1 -1 0 14
+clip plane 3 0 -1 0 7.5
+clip plane 4 1 -1 0 4
+clip plane 5 1 1 0 -6
+enable GL_CLIP_PLANE0
+enable GL_CLIP_PLANE1
+enable GL_CLIP_PLANE2
+enable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+enable GL_CLIP_PLANE5
+draw rect 0.1 0.1 0.8 0.8
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.2, 0.3) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.8, 0.3) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.8, 0.7) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.5, 0.8) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0)
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-enables.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-enables.shader_test
new file mode 100644
index 00000000..b93d16f3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-enables.shader_test
@@ -0,0 +1,147 @@
+# This test sets up 6 clipping planes using gl_ClipVertex, which clip
+# a rectangle to a hexagon shape.  Then it tests various combinations
+# of enables for the 6 clipping planes, and verifies that they all
+# create the correct shape.
+#
+# To verify that each enable works, the combinations of enables were
+# chosen such that:
+# - Every plane is enabled at least once and disbled at least once.
+# - Every plane is enabled and disabled in a different pattern.
+#
+# Note: Some implementations have bugs related to improper coordinate
+# transformations of clip planes (which are already adequately tested
+# by the clip-plane-transformation test), so to avoid those bugs
+# contaminating the results of this test, we don't do any coordinate
+# transformation in this test.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+
+	gl_ClipVertex = gl_Position;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	gl_FragColor = vec4(1, 1, 1, 1);
+}
+
+[test]
+clip plane 0 0 1 0 0.5
+clip plane 1 -1 1 0 0.8
+clip plane 2 -1 -1 0 0.8
+clip plane 3 0 -1 0 0.5
+clip plane 4 1 -1 0 0.8
+clip plane 5 1 1 0 0.8
+clear color 0.0 0.0 0.0 0.0
+
+# Test with planes 0, 2, and 4 enabled.
+enable GL_CLIP_PLANE0
+disable GL_CLIP_PLANE1
+enable GL_CLIP_PLANE2
+disable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+disable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (1.0, 1.0, 1.0, 1.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 5
+
+# Test with planes 0, 1, 4, and 5 enabled.
+enable GL_CLIP_PLANE0
+enable GL_CLIP_PLANE1
+disable GL_CLIP_PLANE2
+disable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+enable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (1.0, 1.0, 1.0, 1.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (1.0, 1.0, 1.0, 1.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 5
+
+# Test with planes 0, 1, 2, and 3 enabled.
+enable GL_CLIP_PLANE0
+enable GL_CLIP_PLANE1
+enable GL_CLIP_PLANE2
+enable GL_CLIP_PLANE3
+disable GL_CLIP_PLANE4
+disable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (0.0, 0.0, 0.0, 0.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (1.0, 1.0, 1.0, 1.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 5
+
+# Test with planes 4 and 5 enabled.
+disable GL_CLIP_PLANE0
+disable GL_CLIP_PLANE1
+disable GL_CLIP_PLANE2
+disable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+enable GL_CLIP_PLANE5
+clear
+draw rect -1 -1 2 2
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.5, 0.2) (1.0, 1.0, 1.0, 1.0) # clipped by plane 0
+relative probe rgba (0.8, 0.3) (1.0, 1.0, 1.0, 1.0) # clipped by plane 1
+relative probe rgba (0.8, 0.7) (1.0, 1.0, 1.0, 1.0) # clipped by plane 2
+relative probe rgba (0.5, 0.8) (1.0, 1.0, 1.0, 1.0) # clipped by plane 3
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0) # clipped by plane 4
+relative probe rgba (0.2, 0.3) (0.0, 0.0, 0.0, 0.0) # clipped by plane 5
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-equal-to-position.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-equal-to-position.shader_test
new file mode 100644
index 00000000..50b4856f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-equal-to-position.shader_test
@@ -0,0 +1,57 @@
+# [description]
+# Use all 6 clip planes to clip a rectangle to a hexagon shape.
+#
+# In this test, gl_Position and gl_ClipVertex are the same.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+	gl_ClipVertex = gl_Position;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	gl_FragColor = vec4(1, 1, 1, 1);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho 0 1 0 1
+clip plane 0 0 1 0 0.5
+clip plane 1 -1 1 0 0.8
+clip plane 2 -1 -1 0 0.8
+clip plane 3 0 -1 0 0.5
+clip plane 4 1 -1 0 0.8
+clip plane 5 1 1 0 0.8
+enable GL_CLIP_PLANE0
+enable GL_CLIP_PLANE1
+enable GL_CLIP_PLANE2
+enable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+enable GL_CLIP_PLANE5
+draw rect 0.1 0.1 0.8 0.8
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.2, 0.3) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.8, 0.3) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.8, 0.7) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.5, 0.8) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0)
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-homogeneity.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-homogeneity.shader_test
new file mode 100644
index 00000000..615ecf9e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/clipping/vs-clip-vertex-homogeneity.shader_test
@@ -0,0 +1,69 @@
+# This test verifies that the homogeneous coordinate of gl_ClipVertex
+# is properly respected, by doubling all the coordinates of
+# gl_ClipVertex (including the homogeneous coordinate) and verifying
+# that the clipped shape is still correct.
+#
+# In addition, this test:
+# - uses all 6 clip planes to clip a rectangle to a hexagon shape.
+# - sets gl_Position and gl_ClipVertex to different values, to verify
+#   that gl_Position determines screen position and gl_ClipVertex
+#   determines clipping.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+	// Transform gl_ClipVertex in an arbitrary way so that
+	// we can verify it is being used for clipping instead of
+	// gl_Position.  The x and y coordinates are multiplied by 5,
+	// and the homogeneous coordinate is multiplied by 0.5, so the
+	// net result should be that x and y are scaled by a factor of
+	// 10.
+	gl_ClipVertex = gl_Vertex * vec4(5.0, 5.0, 1.0, 0.5);
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	gl_FragColor = vec4(1, 1, 1, 1);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho 0 1 0 1
+clip plane 0 0 1 0 -2.5
+clip plane 1 -1 1 0 4
+clip plane 2 -1 -1 0 14
+clip plane 3 0 -1 0 7.5
+clip plane 4 1 -1 0 4
+clip plane 5 1 1 0 -6
+enable GL_CLIP_PLANE0
+enable GL_CLIP_PLANE1
+enable GL_CLIP_PLANE2
+enable GL_CLIP_PLANE3
+enable GL_CLIP_PLANE4
+enable GL_CLIP_PLANE5
+draw rect 0.1 0.1 0.8 0.8
+
+# Test points inside each hexagon edge
+relative probe rgba (0.3, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.3) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.4) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.7, 0.6) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.5, 0.7) (1.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.3, 0.6) (1.0, 1.0, 1.0, 1.0)
+
+# Test points outside each hexagon edge
+relative probe rgba (0.2, 0.3) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.5, 0.2) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.8, 0.3) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.8, 0.7) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.5, 0.8) (0.0, 0.0, 0.0, 0.0)
+relative probe rgba (0.2, 0.7) (0.0, 0.0, 0.0, 0.0)
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-assign-varied-struct.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-assign-varied-struct.shader_test
new file mode 100644
index 00000000..f3ad3e84
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-assign-varied-struct.shader_test
@@ -0,0 +1,36 @@
+# Test initialization of an array of structures where the elements of
+# the structure do not all have the same vector size.
+
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main(void)
+{
+    gl_Position = vertex;
+}
+
+[fragment shader]
+
+void main(void)
+{
+    float x = 3.0;
+    struct s { float f; vec3 v; };
+    s a[1]=s[](s(x,vec3(x)));
+    if (a[0].f==3.0)
+      gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); // green
+    else
+      gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); // red
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2-ivec.shader_test
new file mode 100644
index 00000000..c6925f40
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2-ivec.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec2 r = ivec2(4, 5);
+uniform mat2 expected = mat2(8, 12, 10, 15);
+
+void main() {
+  mat2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2.shader_test
new file mode 100644
index 00000000..a8e91542
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec2 c = vec2(2, 3);
+const vec2 r = vec2(4, 5);
+uniform mat2 expected = mat2(8, 12, 10, 15);
+
+void main() {
+  mat2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x2-ivec.shader_test
new file mode 100644
index 00000000..dc392010
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x2-ivec.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec2 r = ivec2(4, 5);
+uniform mat2x2 expected = mat2x2(8, 12, 10, 15);
+
+void main() {
+  mat2x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x2.shader_test
new file mode 100644
index 00000000..370c3c8b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x2.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec2 c = vec2(2, 3);
+const vec2 r = vec2(4, 5);
+uniform mat2x2 expected = mat2x2(8, 12, 10, 15);
+
+void main() {
+  mat2x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x3-ivec.shader_test
new file mode 100644
index 00000000..9cb881f7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x3-ivec.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec2 r = ivec2(5, 6);
+uniform mat2x3 expected = mat2x3(10, 15, 20, 12, 18, 24);
+
+void main() {
+  mat2x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x3.shader_test
new file mode 100644
index 00000000..925cc8d7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x3.shader_test
@@ -0,0 +1,35 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec2 r = vec2(5, 6);
+uniform mat2x3 expected = mat2x3(10, 15, 20, 12, 18, 24);
+
+void main() {
+  mat2x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x4-ivec.shader_test
new file mode 100644
index 00000000..a67c2051
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x4-ivec.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec2 r = ivec2(6, 7);
+uniform mat2x4 expected = mat2x4(12, 18, 24, 30, 14, 21, 28, 35);
+
+void main() {
+  mat2x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x4.shader_test
new file mode 100644
index 00000000..214a1128
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat2x4.shader_test
@@ -0,0 +1,36 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec2 r = vec2(6, 7);
+uniform mat2x4 expected = mat2x4(12, 18, 24, 30, 14, 21, 28, 35);
+
+void main() {
+  mat2x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3-ivec.shader_test
new file mode 100644
index 00000000..d2e11a6e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3-ivec.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec3 r = ivec3(5, 6, 7);
+uniform mat3 expected = mat3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+
+void main() {
+  mat3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3.shader_test
new file mode 100644
index 00000000..d5011152
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec3 r = vec3(5, 6, 7);
+uniform mat3 expected = mat3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+
+void main() {
+  mat3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x2-ivec.shader_test
new file mode 100644
index 00000000..99292140
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x2-ivec.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec3 r = ivec3(4, 5, 6);
+uniform mat3x2 expected = mat3x2(8, 12, 10, 15, 12, 18);
+
+void main() {
+  mat3x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x2.shader_test
new file mode 100644
index 00000000..3e1ea9eb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x2.shader_test
@@ -0,0 +1,36 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec2 c = vec2(2, 3);
+const vec3 r = vec3(4, 5, 6);
+uniform mat3x2 expected = mat3x2(8, 12, 10, 15, 12, 18);
+
+void main() {
+  mat3x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x3-ivec.shader_test
new file mode 100644
index 00000000..8ad24d4c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x3-ivec.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec3 r = ivec3(5, 6, 7);
+uniform mat3x3 expected = mat3x3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+
+void main() {
+  mat3x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x3.shader_test
new file mode 100644
index 00000000..5371ac93
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x3.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec3 r = vec3(5, 6, 7);
+uniform mat3x3 expected = mat3x3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+
+void main() {
+  mat3x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x4-ivec.shader_test
new file mode 100644
index 00000000..ef994660
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x4-ivec.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec3 r = ivec3(6, 7, 8);
+uniform mat3x4 expected = mat3x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40);
+
+void main() {
+  mat3x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x4.shader_test
new file mode 100644
index 00000000..dd0d4185
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat3x4.shader_test
@@ -0,0 +1,36 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec3 r = vec3(6, 7, 8);
+uniform mat3x4 expected = mat3x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40);
+
+void main() {
+  mat3x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4-ivec.shader_test
new file mode 100644
index 00000000..441ae99a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4-ivec.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec4 r = ivec4(6, 7, 8, 9);
+uniform mat4 expected = mat4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+
+void main() {
+  mat4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4.shader_test
new file mode 100644
index 00000000..ac73bf6a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec4 r = vec4(6, 7, 8, 9);
+uniform mat4 expected = mat4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+
+void main() {
+  mat4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x2-ivec.shader_test
new file mode 100644
index 00000000..0d13ff5a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x2-ivec.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec4 r = ivec4(4, 5, 6, 7);
+uniform mat4x2 expected = mat4x2(8, 12, 10, 15, 12, 18, 14, 21);
+
+void main() {
+  mat4x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x2.shader_test
new file mode 100644
index 00000000..fe76b5dc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x2.shader_test
@@ -0,0 +1,36 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec2 c = vec2(2, 3);
+const vec4 r = vec4(4, 5, 6, 7);
+uniform mat4x2 expected = mat4x2(8, 12, 10, 15, 12, 18, 14, 21);
+
+void main() {
+  mat4x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x3-ivec.shader_test
new file mode 100644
index 00000000..f46e29a4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x3-ivec.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec4 r = ivec4(5, 6, 7, 8);
+uniform mat4x3 expected = mat4x3(10, 15, 20, 12, 18, 24, 14, 21, 28, 16, 24, 32);
+
+void main() {
+  mat4x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x3.shader_test
new file mode 100644
index 00000000..168957bf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x3.shader_test
@@ -0,0 +1,36 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec4 r = vec4(5, 6, 7, 8);
+uniform mat4x3 expected = mat4x3(10, 15, 20, 12, 18, 24, 14, 21, 28, 16, 24, 32);
+
+void main() {
+  mat4x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x4-ivec.shader_test
new file mode 100644
index 00000000..5fa7d9a3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x4-ivec.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec4 r = ivec4(6, 7, 8, 9);
+uniform mat4x4 expected = mat4x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+
+void main() {
+  mat4x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x4.shader_test
new file mode 100644
index 00000000..acabddc5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-const-mat4x4.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec4 r = vec4(6, 7, 8, 9);
+uniform mat4x4 expected = mat4x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+
+void main() {
+  mat4x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2-ivec.shader_test
new file mode 100644
index 00000000..c1a8eb0c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2-ivec.shader_test
@@ -0,0 +1,74 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec2 r;
+uniform mat2 expected;
+
+void main() {
+  mat2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2.shader_test
new file mode 100644
index 00000000..393d36b4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec2 c;
+uniform vec2 r;
+uniform mat2 expected;
+
+void main() {
+  mat2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x2-ivec.shader_test
new file mode 100644
index 00000000..8b2a669e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x2-ivec.shader_test
@@ -0,0 +1,74 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec2 r;
+uniform mat2x2 expected;
+
+void main() {
+  mat2x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x2.shader_test
new file mode 100644
index 00000000..e170e5fd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x2.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec2 c;
+uniform vec2 r;
+uniform mat2x2 expected;
+
+void main() {
+  mat2x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x3-ivec.shader_test
new file mode 100644
index 00000000..f384c372
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x3-ivec.shader_test
@@ -0,0 +1,76 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec2 r;
+uniform mat2x3 expected;
+
+void main() {
+  mat2x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec2 r  5 6
+uniform mat2x3 expected  10 15 20 12 18 24
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec2 r  6 7
+uniform mat2x3 expected  18 24 30 21 28 35
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec2 r  7 8
+uniform mat2x3 expected  28 35 42 32 40 48
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec2 r  8 9
+uniform mat2x3 expected  40 48 56 45 54 63
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x3.shader_test
new file mode 100644
index 00000000..a9c343bc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x3.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec3 c;
+uniform vec2 r;
+uniform mat2x3 expected;
+
+void main() {
+  mat2x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec2 r  5 6
+uniform mat2x3 expected  10 15 20 12 18 24
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec2 r  6 7
+uniform mat2x3 expected  18 24 30 21 28 35
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec2 r  7 8
+uniform mat2x3 expected  28 35 42 32 40 48
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec2 r  8 9
+uniform mat2x3 expected  40 48 56 45 54 63
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x4-ivec.shader_test
new file mode 100644
index 00000000..7e1c74e1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x4-ivec.shader_test
@@ -0,0 +1,76 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec2 r;
+uniform mat2x4 expected;
+
+void main() {
+  mat2x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec2 r  6 7
+uniform mat2x4 expected  12 18 24 30 14 21 28 35
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec2 r  7 8
+uniform mat2x4 expected  21 28 35 42 24 32 40 48
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec2 r  8 9
+uniform mat2x4 expected  32 40 48 56 36 45 54 63
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec2 r  9 10
+uniform mat2x4 expected  45 54 63 72 50 60 70 80
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x4.shader_test
new file mode 100644
index 00000000..0724371c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat2x4.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec4 c;
+uniform vec2 r;
+uniform mat2x4 expected;
+
+void main() {
+  mat2x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec2 r  6 7
+uniform mat2x4 expected  12 18 24 30 14 21 28 35
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec2 r  7 8
+uniform mat2x4 expected  21 28 35 42 24 32 40 48
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec2 r  8 9
+uniform mat2x4 expected  32 40 48 56 36 45 54 63
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec2 r  9 10
+uniform mat2x4 expected  45 54 63 72 50 60 70 80
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3-ivec.shader_test
new file mode 100644
index 00000000..88a0f665
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3-ivec.shader_test
@@ -0,0 +1,74 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec3 r;
+uniform mat3 expected;
+
+void main() {
+  mat3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3.shader_test
new file mode 100644
index 00000000..250b5761
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec3 c;
+uniform vec3 r;
+uniform mat3 expected;
+
+void main() {
+  mat3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x2-ivec.shader_test
new file mode 100644
index 00000000..531cc81a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x2-ivec.shader_test
@@ -0,0 +1,76 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec3 r;
+uniform mat3x2 expected;
+
+void main() {
+  mat3x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec3 r  4 5 6
+uniform mat3x2 expected  8 12 10 15 12 18
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec3 r  5 6 7
+uniform mat3x2 expected  15 20 18 24 21 28
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec3 r  6 7 8
+uniform mat3x2 expected  24 30 28 35 32 40
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec3 r  7 8 9
+uniform mat3x2 expected  35 42 40 48 45 54
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x2.shader_test
new file mode 100644
index 00000000..56c0e9b8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x2.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec2 c;
+uniform vec3 r;
+uniform mat3x2 expected;
+
+void main() {
+  mat3x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec3 r  4 5 6
+uniform mat3x2 expected  8 12 10 15 12 18
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec3 r  5 6 7
+uniform mat3x2 expected  15 20 18 24 21 28
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec3 r  6 7 8
+uniform mat3x2 expected  24 30 28 35 32 40
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec3 r  7 8 9
+uniform mat3x2 expected  35 42 40 48 45 54
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x3-ivec.shader_test
new file mode 100644
index 00000000..940ecae7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x3-ivec.shader_test
@@ -0,0 +1,74 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec3 r;
+uniform mat3x3 expected;
+
+void main() {
+  mat3x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x3.shader_test
new file mode 100644
index 00000000..8a9b2084
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x3.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec3 c;
+uniform vec3 r;
+uniform mat3x3 expected;
+
+void main() {
+  mat3x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x4-ivec.shader_test
new file mode 100644
index 00000000..3e629dca
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x4-ivec.shader_test
@@ -0,0 +1,76 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec3 r;
+uniform mat3x4 expected;
+
+void main() {
+  mat3x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec3 r  6 7 8
+uniform mat3x4 expected  12 18 24 30 14 21 28 35 16 24 32 40
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec3 r  7 8 9
+uniform mat3x4 expected  21 28 35 42 24 32 40 48 27 36 45 54
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec3 r  8 9 10
+uniform mat3x4 expected  32 40 48 56 36 45 54 63 40 50 60 70
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec3 r  9 10 11
+uniform mat3x4 expected  45 54 63 72 50 60 70 80 55 66 77 88
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x4.shader_test
new file mode 100644
index 00000000..a94040df
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat3x4.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec4 c;
+uniform vec3 r;
+uniform mat3x4 expected;
+
+void main() {
+  mat3x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec3 r  6 7 8
+uniform mat3x4 expected  12 18 24 30 14 21 28 35 16 24 32 40
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec3 r  7 8 9
+uniform mat3x4 expected  21 28 35 42 24 32 40 48 27 36 45 54
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec3 r  8 9 10
+uniform mat3x4 expected  32 40 48 56 36 45 54 63 40 50 60 70
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec3 r  9 10 11
+uniform mat3x4 expected  45 54 63 72 50 60 70 80 55 66 77 88
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4-ivec.shader_test
new file mode 100644
index 00000000..4fcc7dfc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4-ivec.shader_test
@@ -0,0 +1,74 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec4 r;
+uniform mat4 expected;
+
+void main() {
+  mat4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4.shader_test
new file mode 100644
index 00000000..1b5c7192
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec4 c;
+uniform vec4 r;
+uniform mat4 expected;
+
+void main() {
+  mat4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x2-ivec.shader_test
new file mode 100644
index 00000000..b2208adc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x2-ivec.shader_test
@@ -0,0 +1,76 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec4 r;
+uniform mat4x2 expected;
+
+void main() {
+  mat4x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec4 r  4 5 6 7
+uniform mat4x2 expected  8 12 10 15 12 18 14 21
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec4 r  5 6 7 8
+uniform mat4x2 expected  15 20 18 24 21 28 24 32
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x2 expected  24 30 28 35 32 40 36 45
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x2 expected  35 42 40 48 45 54 50 60
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x2.shader_test
new file mode 100644
index 00000000..a7c36334
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x2.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec2 c;
+uniform vec4 r;
+uniform mat4x2 expected;
+
+void main() {
+  mat4x2 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec4 r  4 5 6 7
+uniform mat4x2 expected  8 12 10 15 12 18 14 21
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec4 r  5 6 7 8
+uniform mat4x2 expected  15 20 18 24 21 28 24 32
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x2 expected  24 30 28 35 32 40 36 45
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x2 expected  35 42 40 48 45 54 50 60
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x3-ivec.shader_test
new file mode 100644
index 00000000..c479724a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x3-ivec.shader_test
@@ -0,0 +1,76 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec4 r;
+uniform mat4x3 expected;
+
+void main() {
+  mat4x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec4 r  5 6 7 8
+uniform mat4x3 expected  10 15 20 12 18 24 14 21 28 16 24 32
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x3 expected  18 24 30 21 28 35 24 32 40 27 36 45
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x3 expected  28 35 42 32 40 48 36 45 54 40 50 60
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec4 r  8 9 10 11
+uniform mat4x3 expected  40 48 56 45 54 63 50 60 70 55 66 77
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x3.shader_test
new file mode 100644
index 00000000..683d64d7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x3.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec3 c;
+uniform vec4 r;
+uniform mat4x3 expected;
+
+void main() {
+  mat4x3 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec4 r  5 6 7 8
+uniform mat4x3 expected  10 15 20 12 18 24 14 21 28 16 24 32
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x3 expected  18 24 30 21 28 35 24 32 40 27 36 45
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x3 expected  28 35 42 32 40 48 36 45 54 40 50 60
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec4 r  8 9 10 11
+uniform mat4x3 expected  40 48 56 45 54 63 50 60 70 55 66 77
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x4-ivec.shader_test
new file mode 100644
index 00000000..57ef99b0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x4-ivec.shader_test
@@ -0,0 +1,74 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec4 r;
+uniform mat4x4 expected;
+
+void main() {
+  mat4x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x4.shader_test
new file mode 100644
index 00000000..01e79c7d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/fs-outerProduct-mat4x4.shader_test
@@ -0,0 +1,54 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+
+uniform vec4 c;
+uniform vec4 r;
+uniform mat4x4 expected;
+
+void main() {
+  mat4x4 result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxClipPlanes.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxClipPlanes.shader_test
new file mode 100644
index 00000000..16672930
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxClipPlanes.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxClipPlanes >= 6)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxCombinedTextureImageUnits.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxCombinedTextureImageUnits.shader_test
new file mode 100644
index 00000000..a489be05
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxCombinedTextureImageUnits.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxCombinedTextureImageUnits >= 2)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxDrawBuffers.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxDrawBuffers.shader_test
new file mode 100644
index 00000000..e450a1c4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxDrawBuffers.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxDrawBuffers >= 1)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxFragmentUniformComponents.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxFragmentUniformComponents.shader_test
new file mode 100644
index 00000000..3aefbf51
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxFragmentUniformComponents.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxFragmentUniformComponents >= 64)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxLights.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxLights.shader_test
new file mode 100644
index 00000000..3c0fea5b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxLights.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxLights >= 8)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureCoords.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureCoords.shader_test
new file mode 100644
index 00000000..4951ffd0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureCoords.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxTextureCoords >= 2)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureImageUnits.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureImageUnits.shader_test
new file mode 100644
index 00000000..e32faae1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureImageUnits.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxTextureImageUnits >= 2)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureUnits.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureUnits.shader_test
new file mode 100644
index 00000000..52bb5f60
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxTextureUnits.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxTextureUnits >= 2)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVaryingFloats.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVaryingFloats.shader_test
new file mode 100644
index 00000000..2116faa0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVaryingFloats.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxVaryingFloats >= 32)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexAttribs.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexAttribs.shader_test
new file mode 100644
index 00000000..531fe71b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexAttribs.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxVertexAttribs >= 16)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexTextureImageUnits.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexTextureImageUnits.shader_test
new file mode 100644
index 00000000..38fa6475
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexTextureImageUnits.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxVertexTextureImageUnits >= 0)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexUniformComponents.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexUniformComponents.shader_test
new file mode 100644
index 00000000..ae3b7298
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/gl_MaxVertexUniformComponents.shader_test
@@ -0,0 +1,28 @@
+# [description]
+# Tests for GLSL 1.20 minimum maximums for the builtin constants.
+#
+# See the GLSL 1.20.8 specification, section 7.4, page 49 (page 55 of the PDF).
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void main(void)
+{
+	gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+void main(void)
+{
+	if (gl_MaxVertexUniformComponents >= 512)
+		gl_FragColor = vec4(0, 1, 0, 0);
+	else
+		gl_FragColor = vec4(1, 0, 0, 0);
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/maximums/maximums.out b/tests/spec/glsl-es-1.00/execution/1.20/maximums/maximums.out
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/maximums/maximums.out
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/outerProduct-const.sh b/tests/spec/glsl-es-1.00/execution/1.20/outerProduct-const.sh
new file mode 100644
index 00000000..18ba5d03
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/outerProduct-const.sh
@@ -0,0 +1,221 @@
+#!/bin/bash
+
+function emit_conversion_info
+{
+cat <<EOF
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+EOF
+}
+
+function emit_outerProduct_const_data
+{
+    c=$1
+    r=$2
+    vtype=$3
+    mtype=$4
+
+    cbase=$5
+    cvec=""
+    for i in $(seq $c); do
+	v=$(($i + $cbase))
+	if [ "x$cvec" == "x" ]; then
+	    cvec="${v}"
+	else
+	    cvec="${cvec}, ${v}"
+	fi
+    done
+
+    rbase=$(($cbase + $c))
+    rvec=""
+    for i in $(seq $r); do
+	v=$(($i + $rbase))
+	if [ "x$rvec" == "x" ]; then
+	    rvec="${v}"
+	else
+	    rvec="${rvec}, ${v}"
+	fi
+    done
+
+    expected=""
+    for i in $(seq $r); do
+	for j in $(seq $c); do
+	    m=$((($i + $rbase) * ($j + $cbase)))
+	    if [ "x$expected" == "x" ]; then
+		expected="${m}"
+	    else
+		expected="${expected}, ${m}"
+	    fi
+	done
+    done
+
+    echo
+    echo "const ${vtype}${c} c = ${vtype}${c}(${cvec});"
+    echo "const ${vtype}${r} r = ${vtype}${r}(${rvec});"
+    echo "uniform ${mtype} expected = ${mtype}(${expected});"
+
+}
+
+function emit_vs_test
+{
+    c=$1
+    r=$2
+    vtype=$3
+    mat=$4
+
+    if [ "$vtype" = "ivec" ]; then
+	name="vs-outerProduct-const-${mat}-ivec.shader_test"
+    else
+	name="vs-outerProduct-const-${mat}.shader_test"
+    fi
+
+    if [ $c -ne $r ]; then
+	GL_require="# glUniformMatrix${r}x${c}fv only exists in OpenGL 2.1 or later.
+
+"
+    else
+	GL_require=""
+    fi
+
+    cat > $name <<EOF
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+$GL_require
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+EOF
+
+    if [ "$vtype" = "ivec" ]; then
+	emit_conversion_info >> $name
+    fi
+
+    echo "" >> $name
+    emit_outerProduct_const_data $c $r $vtype $mat 1 >> $name
+
+    cat >> $name <<EOF
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  ${mat} result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+EOF
+}
+
+function emit_fs_test
+{
+    c=$1
+    r=$2
+    vtype=$3
+    mat=$4
+
+    if [ "$vtype" = "ivec" ]; then
+	name="fs-outerProduct-const-${mat}-ivec.shader_test"
+    else
+	name="fs-outerProduct-const-${mat}.shader_test"
+    fi
+
+    if [ $c -ne $r ]; then
+	GL_require="# glUniformMatrix${r}x${c}fv only exists in OpenGL 2.1 or later.
+
+"
+    else
+	GL_require=""
+    fi
+
+    cat > $name <<EOF
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+$GL_require
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+EOF
+
+    if [ "$vtype" = "ivec" ]; then
+	emit_conversion_info >> $name
+    fi
+
+    echo "" >> $name
+    emit_outerProduct_const_data $c $r $vtype $mat 1 >> $name
+
+    cat >> $name <<EOF
+
+void main() {
+  ${mat} result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+EOF
+}
+
+for c in 2 3 4; do
+    for r in 2 3 4; do
+	emit_vs_test $c $r  vec "mat${r}x${c}"
+	emit_vs_test $c $r ivec "mat${r}x${c}"
+	emit_fs_test $c $r  vec "mat${r}x${c}"
+	emit_fs_test $c $r ivec "mat${r}x${c}"
+	if [ $c -eq $r ]; then
+	    emit_vs_test $c $r  vec "mat${r}"
+	    emit_vs_test $c $r ivec "mat${r}"
+	    emit_fs_test $c $r  vec "mat${r}"
+	    emit_fs_test $c $r ivec "mat${r}"
+	fi
+    done
+done
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/outerProduct.sh b/tests/spec/glsl-es-1.00/execution/1.20/outerProduct.sh
new file mode 100644
index 00000000..98d5d98c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/outerProduct.sh
@@ -0,0 +1,217 @@
+#!/bin/bash
+
+function emit_conversion_info
+{
+cat <<EOF
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+EOF
+}
+
+function emit_outerProduct_data
+{
+    c=$1
+    r=$2
+    vtype=$3
+
+    cbase=$4
+    cvec=""
+    for i in $(seq $c); do
+	v=$(($i + $cbase))
+	cvec="${cvec} ${v}"
+    done
+
+    rbase=$(($cbase + $c))
+    rvec=""
+    for i in $(seq $r); do
+	v=$(($i + $rbase))
+	rvec="${rvec} ${v}"
+    done
+
+    mat=""
+    for i in $(seq $r); do
+	for j in $(seq $c); do
+	    m=$((($i + $rbase) * ($j + $cbase)))
+	    mat="${mat} ${m}"
+	done
+    done
+
+    echo
+    echo "uniform ${vtype}${c} c ${cvec}"
+    echo "uniform ${vtype}${r} r ${rvec}"
+    echo "uniform mat${r}x${c} expected ${mat}"
+
+    x=$((20 * $4 - 10))
+    echo "draw rect $x 10 10 10"
+    echo "probe rgb $(($x + 5)) 15 0.0 1.0 0.0"
+}
+
+function emit_vs_test
+{
+    c=$1
+    r=$2
+    vtype=$3
+    mat=$4
+
+    if [ "$vtype" = "ivec" ]; then
+	name="vs-outerProduct-${mat}-ivec.shader_test"
+    else
+	name="vs-outerProduct-${mat}.shader_test"
+    fi
+
+    if [ $c -ne $r ]; then
+	GL_require="# glUniformMatrix${r}x${c}fv only exists in OpenGL 2.1 or later.
+
+"
+    else
+	GL_require=""
+    fi
+
+    cat > $name <<EOF
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+$GL_require
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+EOF
+
+    if [ "$vtype" = "ivec" ]; then
+	emit_conversion_info >> $name
+    fi
+
+    cat >> $name <<EOF
+
+uniform ${vtype}${c} c;
+uniform ${vtype}${r} r;
+uniform ${mat} expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  ${mat} result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+EOF
+
+    emit_outerProduct_data $c $r $vtype 1 >> $name
+    emit_outerProduct_data $c $r $vtype 2 >> $name
+    emit_outerProduct_data $c $r $vtype 3 >> $name
+    emit_outerProduct_data $c $r $vtype 4 >> $name
+}
+
+function emit_fs_test
+{
+    c=$1
+    r=$2
+    vtype=$3
+    mat=$4
+
+    if [ "$vtype" = "ivec" ]; then
+	name="fs-outerProduct-${mat}-ivec.shader_test"
+    else
+	name="fs-outerProduct-${mat}.shader_test"
+    fi
+
+    if [ $c -ne $r ]; then
+	GL_require="# glUniformMatrix${r}x${c}fv only exists in OpenGL 2.1 or later.
+
+"
+    else
+	GL_require=""
+    fi
+
+    cat > $name <<EOF
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+$GL_require
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main() { gl_Position = vertex;
+	gl_Position *= proj; }
+
+[fragment shader]
+EOF
+
+    if [ "$vtype" = "ivec" ]; then
+	emit_conversion_info >> $name
+    fi
+
+    cat >> $name <<EOF
+
+uniform ${vtype}${c} c;
+uniform ${vtype}${r} r;
+uniform ${mat} expected;
+
+void main() {
+  ${mat} result = outerProduct(c, r);
+  gl_FragColor = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+EOF
+
+    emit_outerProduct_data $c $r $vtype 1 >> $name
+    emit_outerProduct_data $c $r $vtype 2 >> $name
+    emit_outerProduct_data $c $r $vtype 3 >> $name
+    emit_outerProduct_data $c $r $vtype 4 >> $name
+}
+
+for c in 2 3 4; do
+    for r in 2 3 4; do
+	emit_vs_test $c $r  vec "mat${r}x${c}"
+	emit_vs_test $c $r ivec "mat${r}x${c}"
+	emit_fs_test $c $r  vec "mat${r}x${c}"
+	emit_fs_test $c $r ivec "mat${r}x${c}"
+	if [ $c -eq $r ]; then
+	    emit_vs_test $c $r  vec "mat${r}"
+	    emit_vs_test $c $r ivec "mat${r}"
+	    emit_fs_test $c $r  vec "mat${r}"
+	    emit_fs_test $c $r ivec "mat${r}"
+	fi
+    done
+done
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/qualifiers.out b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/qualifiers.out
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/qualifiers.out
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-int-float-to-float-float-float-return.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-int-float-to-float-float-float-return.shader_test
new file mode 100644
index 00000000..15743c53
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-int-float-to-float-float-float-return.shader_test
@@ -0,0 +1,46 @@
+# Test that implicit type conversion of out parameters works properly.
+#
+# From the GLSL 1.30 spec (which clarifies, but does not change, the
+# rules for implicit type conversion in GLSL 1.20), section 6.1
+# (Function Definitions):
+#
+#   Mismatched types on output parameters (out or inout) must have a
+#   conversion from the formal parameter type to the calling argument
+#   type.
+#
+# This test uses a complex function signature with three out
+# parameters of various types, and a return value, to make sure the
+# outputs aren't mixed up.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+float f(out int x, out int y, out float z)
+{
+  x = 4;
+  y = 5;
+  z = 0.75;
+  return 0.5;
+}
+
+void main()
+{
+  gl_Position = gl_Vertex;
+  float value1;
+  float value2;
+  float value3;
+  float value4 = f(value1, value2, value3);
+  gl_FrontColor = vec4(1.0/value1, 1.0/value2, value3, value4);
+}
+
+[fragment shader]
+void main()
+{
+  gl_FragColor = gl_Color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.25 0.2 0.75 0.5
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-to-float-return.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-to-float-return.shader_test
new file mode 100644
index 00000000..cf7f2b9f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-to-float-return.shader_test
@@ -0,0 +1,41 @@
+# Test that implicit type conversion of out parameters works properly.
+#
+# From the GLSL 1.30 spec (which clarifies, but does not change, the
+# rules for implicit type conversion in GLSL 1.20), section 6.1
+# (Function Definitions):
+#
+#   Mismatched types on output parameters (out or inout) must have a
+#   conversion from the formal parameter type to the calling argument
+#   type.
+#
+# This test uses a simple function returning float and taking a single
+# out parameter.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+float f(out int x)
+{
+  x = 4;
+  return 0.5;
+}
+
+void main()
+{
+  gl_Position = gl_Vertex;
+  float value1;
+  float value2 = f(value1);
+  gl_FrontColor = vec4(1.0/value1, value2, 0.0, 0.0);
+}
+
+[fragment shader]
+void main()
+{
+  gl_FragColor = gl_Color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.25 0.5 0.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-to-float.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-to-float.shader_test
new file mode 100644
index 00000000..2c3a2ce7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/qualifiers/vs-out-conversion-int-to-float.shader_test
@@ -0,0 +1,40 @@
+# Test that implicit type conversion of out parameters works properly.
+#
+# From the GLSL 1.30 spec (which clarifies, but does not change, the
+# rules for implicit type conversion in GLSL 1.20), section 6.1
+# (Function Definitions):
+#
+#   Mismatched types on output parameters (out or inout) must have a
+#   conversion from the formal parameter type to the calling argument
+#   type.
+#
+# This test uses a simple function returning void and taking a single
+# out parameter.
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+void f(out int x)
+{
+  x = 4;
+}
+
+void main()
+{
+  gl_Position = gl_Vertex;
+  float value;
+  f(value);
+  gl_FrontColor = vec4(1.0/value);
+}
+
+[fragment shader]
+void main()
+{
+  gl_FragColor = gl_Color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.25 0.25 0.25 0.25
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/fs-structure-array.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/fs-structure-array.shader_test
new file mode 100644
index 00000000..36f56444
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/fs-structure-array.shader_test
@@ -0,0 +1,48 @@
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+
+void main()
+{
+  gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+
+struct S {
+  int i;
+  float f;
+  vec4 v[2];
+};
+
+uniform S s[2] = S[2](S(9, 33.3, vec4[2](vec4(1, 2, 3, 4),
+					 vec4(9, 8, 7, 6))),
+		      S(7, 22.2, vec4[2](vec4(5, 6, 7, 8),
+					 vec4(3, 2, 1, 0))));
+
+void main()
+{
+  vec4 color;
+
+  if (s[0].i == 9
+      && s[0].f == 33.3
+      && s[0].v[0] == vec4(1, 2, 3, 4)
+      && s[0].v[1] == vec4(9, 8, 7, 6)
+      && s[1].i == 7
+      && s[1].f == 22.2
+      && s[1].v[0] == vec4(5, 6, 7, 8)
+      && s[1].v[1] == vec4(3, 2, 1, 0)) {
+    color = vec4(0, 1, 0, 1);
+  } else {
+    color = vec4(1, 0, 0, 1);
+  }
+
+  gl_FragColor = color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgb 0 1 0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/fs-structure.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/fs-structure.shader_test
new file mode 100644
index 00000000..3b0c9509
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/fs-structure.shader_test
@@ -0,0 +1,44 @@
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+
+void main()
+{
+  gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+varying vec4 color;
+
+struct S {
+  int i;
+  float f;
+  vec4 v[2];
+};
+
+uniform S s = S(9, 33.3, vec4[2](vec4(1, 2, 3, 4),
+				 vec4(9, 8, 7, 6)));
+
+void main()
+{
+  vec4 color;
+
+  if (s.i == 9
+      && s.f == 33.3
+      && s.v[0] == vec4(1, 2, 3, 4)
+      && s.v[1] == vec4(9, 8, 7, 6)) {
+    color = vec4(0, 1, 0, 1);
+  } else {
+    color = vec4(1, 0, 0, 1);
+  }
+
+
+  gl_FragColor = color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgb 0 1 0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/uniform-initializer.out b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/uniform-initializer.out
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/uniform-initializer.out
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/vs-structure-array.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/vs-structure-array.shader_test
new file mode 100644
index 00000000..7b8bd508
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/vs-structure-array.shader_test
@@ -0,0 +1,48 @@
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+
+struct S {
+  int i;
+  float f;
+  vec4 v[2];
+};
+
+uniform S s[2] = S[2](S(9, 33.3, vec4[2](vec4(1, 2, 3, 4),
+					 vec4(9, 8, 7, 6))),
+		      S(7, 22.2, vec4[2](vec4(5, 6, 7, 8),
+					 vec4(3, 2, 1, 0))));
+varying vec4 color;
+
+void main()
+{
+  if (s[0].i == 9
+      && s[0].f == 33.3
+      && s[0].v[0] == vec4(1, 2, 3, 4)
+      && s[0].v[1] == vec4(9, 8, 7, 6)
+      && s[1].i == 7
+      && s[1].f == 22.2
+      && s[1].v[0] == vec4(5, 6, 7, 8)
+      && s[1].v[1] == vec4(3, 2, 1, 0)) {
+    color = vec4(0, 1, 0, 1);
+  } else {
+    color = vec4(1, 0, 0, 1);
+  }
+
+  gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+varying vec4 color;
+
+void main()
+{
+  gl_FragColor = color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgb 0 1 0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/vs-structure.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/vs-structure.shader_test
new file mode 100644
index 00000000..f2fa32d1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/uniform-initializer/vs-structure.shader_test
@@ -0,0 +1,42 @@
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+
+struct S {
+  int i;
+  float f;
+  vec4 v[2];
+};
+
+uniform S s = S(9, 33.3, vec4[2](vec4(1, 2, 3, 4),
+				 vec4(9, 8, 7, 6)));
+varying vec4 color;
+
+void main()
+{
+  if (s.i == 9
+      && s.f == 33.3
+      && s.v[0] == vec4(1, 2, 3, 4)
+      && s.v[1] == vec4(9, 8, 7, 6)) {
+    color = vec4(0, 1, 0, 1);
+  } else {
+    color = vec4(1, 0, 0, 1);
+  }
+
+  gl_Position = gl_Vertex;
+}
+
+[fragment shader]
+#version 120
+varying vec4 color;
+
+void main()
+{
+  gl_FragColor = color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgb 0 1 0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-rd.shader_test
new file mode 100644
index 00000000..63d9533e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-rd.shader_test
@@ -0,0 +1,46 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..4966e069
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-row-rd.shader_test
@@ -0,0 +1,60 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test
new file mode 100644
index 00000000..5bc8ebf0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-row-wr.shader_test
@@ -0,0 +1,75 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-wr.shader_test
new file mode 100644
index 00000000..32eeaf98
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-col-wr.shader_test
@@ -0,0 +1,56 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test
new file mode 100644
index 00000000..61df7269
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-rd.shader_test
@@ -0,0 +1,71 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 expect 9 10
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test
new file mode 100644
index 00000000..568bbeb1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-row-rd.shader_test
@@ -0,0 +1,109 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 9
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test
new file mode 100644
index 00000000..eca3415e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-row-wr.shader_test
@@ -0,0 +1,146 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test
new file mode 100644
index 00000000..df1d6437
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-col-wr.shader_test
@@ -0,0 +1,91 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-rd.shader_test
new file mode 100644
index 00000000..aba81276
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-rd.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test
new file mode 100644
index 00000000..9f617442
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-row-rd.shader_test
@@ -0,0 +1,71 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test
new file mode 100644
index 00000000..d4fff20a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-row-wr.shader_test
@@ -0,0 +1,92 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-wr.shader_test
new file mode 100644
index 00000000..2ec45d99
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-index-wr.shader_test
@@ -0,0 +1,64 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-rd.shader_test
new file mode 100644
index 00000000..572ea225
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-rd.shader_test
@@ -0,0 +1,38 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-row-rd.shader_test
new file mode 100644
index 00000000..5219fd81
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-row-rd.shader_test
@@ -0,0 +1,46 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-row-wr.shader_test
new file mode 100644
index 00000000..a9efc766
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-row-wr.shader_test
@@ -0,0 +1,57 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-wr.shader_test
new file mode 100644
index 00000000..bdb4c0b6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat2-wr.shader_test
@@ -0,0 +1,47 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-rd.shader_test
new file mode 100644
index 00000000..a07de223
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-rd.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..d8481c34
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-row-rd.shader_test
@@ -0,0 +1,86 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test
new file mode 100644
index 00000000..104b77c3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-row-wr.shader_test
@@ -0,0 +1,116 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-wr.shader_test
new file mode 100644
index 00000000..af914683
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-col-wr.shader_test
@@ -0,0 +1,64 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test
new file mode 100644
index 00000000..26f4803d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-rd.shader_test
@@ -0,0 +1,86 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 expect 19 20 21
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 25 26 27
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test
new file mode 100644
index 00000000..f4dc1658
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-row-rd.shader_test
@@ -0,0 +1,187 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 19
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 20
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 21
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test
new file mode 100644
index 00000000..764e46bb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-row-wr.shader_test
@@ -0,0 +1,269 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test
new file mode 100644
index 00000000..a072a36a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-col-wr.shader_test
@@ -0,0 +1,115 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-rd.shader_test
new file mode 100644
index 00000000..c3667bad
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-rd.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test
new file mode 100644
index 00000000..c2c386cf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-row-rd.shader_test
@@ -0,0 +1,86 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test
new file mode 100644
index 00000000..ab0b7b35
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-row-wr.shader_test
@@ -0,0 +1,116 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-wr.shader_test
new file mode 100644
index 00000000..2f1445f9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-index-wr.shader_test
@@ -0,0 +1,64 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-rd.shader_test
new file mode 100644
index 00000000..a32691d7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-rd.shader_test
@@ -0,0 +1,38 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-row-rd.shader_test
new file mode 100644
index 00000000..a9a33b72
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-row-rd.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-row-wr.shader_test
new file mode 100644
index 00000000..a79bbb6c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-row-wr.shader_test
@@ -0,0 +1,65 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-wr.shader_test
new file mode 100644
index 00000000..8b6ec754
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat3-wr.shader_test
@@ -0,0 +1,47 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-rd.shader_test
new file mode 100644
index 00000000..e6383c4b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-rd.shader_test
@@ -0,0 +1,56 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..849a94da
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-row-rd.shader_test
@@ -0,0 +1,122 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test
new file mode 100644
index 00000000..20c6c276
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-row-wr.shader_test
@@ -0,0 +1,173 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-wr.shader_test
new file mode 100644
index 00000000..af2621e5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-col-wr.shader_test
@@ -0,0 +1,72 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test
new file mode 100644
index 00000000..11bfc83c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-rd.shader_test
@@ -0,0 +1,101 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 expect 33 34 35 36
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 41 42 43 44
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 45 46 47 48
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test
new file mode 100644
index 00000000..5ae1f738
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-row-rd.shader_test
@@ -0,0 +1,295 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 33
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 34
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 35
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 36
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 41
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 42
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 43
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 44
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 45
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 46
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 47
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 48
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test
new file mode 100644
index 00000000..0550579b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-row-wr.shader_test
@@ -0,0 +1,440 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test
new file mode 100644
index 00000000..5568cd3d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-col-wr.shader_test
@@ -0,0 +1,139 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-rd.shader_test
new file mode 100644
index 00000000..1b9e6bb3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-rd.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test
new file mode 100644
index 00000000..39217b5e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-row-rd.shader_test
@@ -0,0 +1,101 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test
new file mode 100644
index 00000000..ec7930e9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-row-wr.shader_test
@@ -0,0 +1,140 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-wr.shader_test
new file mode 100644
index 00000000..ec818d3d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-index-wr.shader_test
@@ -0,0 +1,64 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-rd.shader_test
new file mode 100644
index 00000000..2c6b3a42
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-rd.shader_test
@@ -0,0 +1,38 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-row-rd.shader_test
new file mode 100644
index 00000000..6dc8226f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-row-rd.shader_test
@@ -0,0 +1,56 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-row-wr.shader_test
new file mode 100644
index 00000000..d64a3c19
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-row-wr.shader_test
@@ -0,0 +1,73 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-wr.shader_test
new file mode 100644
index 00000000..d9435d8d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-array-mat4-wr.shader_test
@@ -0,0 +1,47 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-rd.shader_test
new file mode 100644
index 00000000..cb42f4fd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-rd.shader_test
@@ -0,0 +1,43 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..90342909
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-row-rd.shader_test
@@ -0,0 +1,57 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-row-wr.shader_test
new file mode 100644
index 00000000..b9826f9c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-row-wr.shader_test
@@ -0,0 +1,70 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-wr.shader_test
new file mode 100644
index 00000000..07bfacdd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-col-wr.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-rd.shader_test
new file mode 100644
index 00000000..972a2815
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-rd.shader_test
@@ -0,0 +1,35 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-row-rd.shader_test
new file mode 100644
index 00000000..a625dfc0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-row-rd.shader_test
@@ -0,0 +1,43 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-row-wr.shader_test
new file mode 100644
index 00000000..ea43a75d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-row-wr.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-wr.shader_test
new file mode 100644
index 00000000..16ccfffa
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat2-wr.shader_test
@@ -0,0 +1,42 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-rd.shader_test
new file mode 100644
index 00000000..0e9c7885
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-rd.shader_test
@@ -0,0 +1,48 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..f05662cc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-row-rd.shader_test
@@ -0,0 +1,83 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-row-wr.shader_test
new file mode 100644
index 00000000..0c6f1ad5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-row-wr.shader_test
@@ -0,0 +1,111 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-wr.shader_test
new file mode 100644
index 00000000..f5010632
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-col-wr.shader_test
@@ -0,0 +1,59 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-rd.shader_test
new file mode 100644
index 00000000..e67303c7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-rd.shader_test
@@ -0,0 +1,35 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-row-rd.shader_test
new file mode 100644
index 00000000..260e53e2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-row-rd.shader_test
@@ -0,0 +1,48 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-row-wr.shader_test
new file mode 100644
index 00000000..7d2a5a8c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-row-wr.shader_test
@@ -0,0 +1,60 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-wr.shader_test
new file mode 100644
index 00000000..80fe56a6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat3-wr.shader_test
@@ -0,0 +1,42 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-rd.shader_test
new file mode 100644
index 00000000..a8678072
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-rd.shader_test
@@ -0,0 +1,53 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..f7fb2f63
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-row-rd.shader_test
@@ -0,0 +1,119 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-row-wr.shader_test
new file mode 100644
index 00000000..2a6ffad3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-row-wr.shader_test
@@ -0,0 +1,168 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-wr.shader_test
new file mode 100644
index 00000000..29a067c0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-col-wr.shader_test
@@ -0,0 +1,67 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-rd.shader_test
new file mode 100644
index 00000000..042dc594
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-rd.shader_test
@@ -0,0 +1,35 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-row-rd.shader_test
new file mode 100644
index 00000000..c8e661a3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-row-rd.shader_test
@@ -0,0 +1,53 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-row-wr.shader_test
new file mode 100644
index 00000000..0499571d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-row-wr.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-wr.shader_test
new file mode 100644
index 00000000..65e77671
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-temp-mat4-wr.shader_test
@@ -0,0 +1,42 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; }
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test
new file mode 100644
index 00000000..7fb447eb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-col-rd.shader_test
@@ -0,0 +1,49 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..8fa799d9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-col-row-rd.shader_test
@@ -0,0 +1,63 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test
new file mode 100644
index 00000000..506783c7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-col-rd.shader_test
@@ -0,0 +1,74 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 expect 9 10
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test
new file mode 100644
index 00000000..54f32bf0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-col-row-rd.shader_test
@@ -0,0 +1,112 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 9
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test
new file mode 100644
index 00000000..497de096
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test
new file mode 100644
index 00000000..4f2eae0d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-index-row-rd.shader_test
@@ -0,0 +1,74 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-rd.shader_test
new file mode 100644
index 00000000..b7346554
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-rd.shader_test
@@ -0,0 +1,41 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test
new file mode 100644
index 00000000..b393cf1c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat2-row-rd.shader_test
@@ -0,0 +1,49 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test
new file mode 100644
index 00000000..e8f28939
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-col-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..6b9a7c0b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-col-row-rd.shader_test
@@ -0,0 +1,89 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test
new file mode 100644
index 00000000..c45e4b1b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-col-rd.shader_test
@@ -0,0 +1,89 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 expect 19 20 21
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 25 26 27
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test
new file mode 100644
index 00000000..9022e743
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-col-row-rd.shader_test
@@ -0,0 +1,190 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 19
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 20
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 21
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test
new file mode 100644
index 00000000..c7eb6bfe
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test
new file mode 100644
index 00000000..cfa0b462
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-index-row-rd.shader_test
@@ -0,0 +1,89 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-rd.shader_test
new file mode 100644
index 00000000..34b0f668
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-rd.shader_test
@@ -0,0 +1,41 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test
new file mode 100644
index 00000000..a2b59571
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat3-row-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test
new file mode 100644
index 00000000..ab2e7da5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-col-rd.shader_test
@@ -0,0 +1,59 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..8949806a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-col-row-rd.shader_test
@@ -0,0 +1,125 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test
new file mode 100644
index 00000000..f55cdb45
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-col-rd.shader_test
@@ -0,0 +1,104 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 expect 33 34 35 36
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 41 42 43 44
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 45 46 47 48
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test
new file mode 100644
index 00000000..7a0623b9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-col-row-rd.shader_test
@@ -0,0 +1,298 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 33
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 34
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 35
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 36
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 41
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 42
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 43
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 44
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 45
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 46
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 47
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 48
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test
new file mode 100644
index 00000000..07329220
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test
new file mode 100644
index 00000000..c5a21c7b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-index-row-rd.shader_test
@@ -0,0 +1,104 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-rd.shader_test
new file mode 100644
index 00000000..ade091db
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-rd.shader_test
@@ -0,0 +1,41 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test
new file mode 100644
index 00000000..fadf92d3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-array-mat4-row-rd.shader_test
@@ -0,0 +1,59 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-col-rd.shader_test
new file mode 100644
index 00000000..e746610f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-col-rd.shader_test
@@ -0,0 +1,43 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..3fccb2b1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-col-row-rd.shader_test
@@ -0,0 +1,57 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-rd.shader_test
new file mode 100644
index 00000000..21adf9b9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-rd.shader_test
@@ -0,0 +1,35 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-row-rd.shader_test
new file mode 100644
index 00000000..f0308704
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat2-row-rd.shader_test
@@ -0,0 +1,43 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-col-rd.shader_test
new file mode 100644
index 00000000..d8cf0f9d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-col-rd.shader_test
@@ -0,0 +1,48 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..9b7bf9d9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-col-row-rd.shader_test
@@ -0,0 +1,83 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-rd.shader_test
new file mode 100644
index 00000000..3ac08a78
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-rd.shader_test
@@ -0,0 +1,35 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-row-rd.shader_test
new file mode 100644
index 00000000..ef9b606e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat3-row-rd.shader_test
@@ -0,0 +1,48 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-col-rd.shader_test
new file mode 100644
index 00000000..347eabc3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-col-rd.shader_test
@@ -0,0 +1,53 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..e933419b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-col-row-rd.shader_test
@@ -0,0 +1,119 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-rd.shader_test
new file mode 100644
index 00000000..b0e5349f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-rd.shader_test
@@ -0,0 +1,35 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-row-rd.shader_test
new file mode 100644
index 00000000..132dd447
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-uniform-mat4-row-rd.shader_test
@@ -0,0 +1,53 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-col-rd.shader_test
new file mode 100644
index 00000000..f6e18948
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-col-rd.shader_test
@@ -0,0 +1,47 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..a55ef831
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-col-row-rd.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test
new file mode 100644
index 00000000..9490c599
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-col-rd.shader_test
@@ -0,0 +1,72 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 expect 9 10
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test
new file mode 100644
index 00000000..ccd18dff
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-col-row-rd.shader_test
@@ -0,0 +1,110 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 9
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-rd.shader_test
new file mode 100644
index 00000000..fb5b3c7f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test
new file mode 100644
index 00000000..996da969
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-index-row-rd.shader_test
@@ -0,0 +1,72 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-rd.shader_test
new file mode 100644
index 00000000..a732fac3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-rd.shader_test
@@ -0,0 +1,39 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-row-rd.shader_test
new file mode 100644
index 00000000..c5774d54
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat2-row-rd.shader_test
@@ -0,0 +1,47 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-col-rd.shader_test
new file mode 100644
index 00000000..5bd5208a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-col-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..d84c8abe
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-col-row-rd.shader_test
@@ -0,0 +1,87 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test
new file mode 100644
index 00000000..dc696854
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-col-rd.shader_test
@@ -0,0 +1,87 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 expect 19 20 21
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 25 26 27
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test
new file mode 100644
index 00000000..baef9e35
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-col-row-rd.shader_test
@@ -0,0 +1,188 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 19
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 20
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 21
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-rd.shader_test
new file mode 100644
index 00000000..9eaf28bd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test
new file mode 100644
index 00000000..333f2209
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-index-row-rd.shader_test
@@ -0,0 +1,87 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-rd.shader_test
new file mode 100644
index 00000000..a812ac5c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-rd.shader_test
@@ -0,0 +1,39 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-row-rd.shader_test
new file mode 100644
index 00000000..31c02031
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat3-row-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-col-rd.shader_test
new file mode 100644
index 00000000..6dc38ec9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-col-rd.shader_test
@@ -0,0 +1,57 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..3cb4de04
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-col-row-rd.shader_test
@@ -0,0 +1,123 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test
new file mode 100644
index 00000000..fba08678
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-col-rd.shader_test
@@ -0,0 +1,102 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 expect 33 34 35 36
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 41 42 43 44
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 45 46 47 48
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test
new file mode 100644
index 00000000..d017a225
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-col-row-rd.shader_test
@@ -0,0 +1,296 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 33
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 34
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 35
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 36
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 41
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 42
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 43
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 44
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 45
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 46
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 47
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 48
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-rd.shader_test
new file mode 100644
index 00000000..b2a09792
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test
new file mode 100644
index 00000000..f2908a2f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-index-row-rd.shader_test
@@ -0,0 +1,102 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-rd.shader_test
new file mode 100644
index 00000000..37075ccf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-rd.shader_test
@@ -0,0 +1,39 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-row-rd.shader_test
new file mode 100644
index 00000000..acf00efe
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-array-mat4-row-rd.shader_test
@@ -0,0 +1,57 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-col-rd.shader_test
new file mode 100644
index 00000000..e7a4a00f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-col-rd.shader_test
@@ -0,0 +1,45 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..965172d8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-col-row-rd.shader_test
@@ -0,0 +1,59 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-rd.shader_test
new file mode 100644
index 00000000..34dcf37e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-rd.shader_test
@@ -0,0 +1,37 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-row-rd.shader_test
new file mode 100644
index 00000000..1e7f5307
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat2-row-rd.shader_test
@@ -0,0 +1,45 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-col-rd.shader_test
new file mode 100644
index 00000000..bfb90277
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-col-rd.shader_test
@@ -0,0 +1,50 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..71cdc60e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-col-row-rd.shader_test
@@ -0,0 +1,85 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-rd.shader_test
new file mode 100644
index 00000000..0bb62f8a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-rd.shader_test
@@ -0,0 +1,37 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-row-rd.shader_test
new file mode 100644
index 00000000..33b85391
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat3-row-rd.shader_test
@@ -0,0 +1,50 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-col-rd.shader_test
new file mode 100644
index 00000000..df81b9b1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-col-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..f719693a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-col-row-rd.shader_test
@@ -0,0 +1,121 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-rd.shader_test
new file mode 100644
index 00000000..21b4dc96
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-rd.shader_test
@@ -0,0 +1,37 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-row-rd.shader_test
new file mode 100644
index 00000000..b1460a43
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/fs-varying-mat4-row-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/variable-indexing.out b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/variable-indexing.out
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/variable-indexing.out
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-rd.shader_test
new file mode 100644
index 00000000..2d2ee907
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-rd.shader_test
@@ -0,0 +1,47 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..983b3802
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-row-rd.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test
new file mode 100644
index 00000000..0694e6c8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-row-wr.shader_test
@@ -0,0 +1,79 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-wr.shader_test
new file mode 100644
index 00000000..107c552c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-col-wr.shader_test
@@ -0,0 +1,60 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test
new file mode 100644
index 00000000..87d54786
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-rd.shader_test
@@ -0,0 +1,72 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 expect 9 10
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test
new file mode 100644
index 00000000..93b4ede0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-row-rd.shader_test
@@ -0,0 +1,110 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 9
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test
new file mode 100644
index 00000000..dd8000f0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-row-wr.shader_test
@@ -0,0 +1,150 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test
new file mode 100644
index 00000000..e1791a84
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-col-wr.shader_test
@@ -0,0 +1,95 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-rd.shader_test
new file mode 100644
index 00000000..e73f83ce
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test
new file mode 100644
index 00000000..06e6ad81
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-row-rd.shader_test
@@ -0,0 +1,72 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test
new file mode 100644
index 00000000..ffdd2abe
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-row-wr.shader_test
@@ -0,0 +1,96 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-wr.shader_test
new file mode 100644
index 00000000..9b57db0d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-index-wr.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-rd.shader_test
new file mode 100644
index 00000000..771ce237
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-rd.shader_test
@@ -0,0 +1,39 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-row-rd.shader_test
new file mode 100644
index 00000000..81a666ee
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-row-rd.shader_test
@@ -0,0 +1,47 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] m = mat2x2[3](
+        mat2x2(1.0, 2.0, 3.0, 4.0),
+        mat2x2(5.0, 6.0, 7.0, 8.0),
+        mat2x2(9.0, 10.0, 11.0, 12.0));
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-row-wr.shader_test
new file mode 100644
index 00000000..acdefb9e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-row-wr.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-wr.shader_test
new file mode 100644
index 00000000..4c563c7d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat2-wr.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2[3] dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-rd.shader_test
new file mode 100644
index 00000000..1bc756d2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..b8d5ba29
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-row-rd.shader_test
@@ -0,0 +1,87 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test
new file mode 100644
index 00000000..c7d2fec0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-row-wr.shader_test
@@ -0,0 +1,120 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-wr.shader_test
new file mode 100644
index 00000000..f9b75df6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-col-wr.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test
new file mode 100644
index 00000000..855b642a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-rd.shader_test
@@ -0,0 +1,87 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 expect 19 20 21
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 25 26 27
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test
new file mode 100644
index 00000000..2b0c8541
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-row-rd.shader_test
@@ -0,0 +1,188 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 19
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 20
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 21
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test
new file mode 100644
index 00000000..c8574af6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-row-wr.shader_test
@@ -0,0 +1,273 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test
new file mode 100644
index 00000000..8555c1e7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-col-wr.shader_test
@@ -0,0 +1,119 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-rd.shader_test
new file mode 100644
index 00000000..603d5b7a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test
new file mode 100644
index 00000000..a9428ea2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-row-rd.shader_test
@@ -0,0 +1,87 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test
new file mode 100644
index 00000000..18deb57f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-row-wr.shader_test
@@ -0,0 +1,120 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-wr.shader_test
new file mode 100644
index 00000000..24ccd462
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-index-wr.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-rd.shader_test
new file mode 100644
index 00000000..d8ccdebf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-rd.shader_test
@@ -0,0 +1,39 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-row-rd.shader_test
new file mode 100644
index 00000000..cc67904b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-row-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] m = mat3x3[3](
+        mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+        mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+        mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-row-wr.shader_test
new file mode 100644
index 00000000..fafac2ae
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-row-wr.shader_test
@@ -0,0 +1,69 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-wr.shader_test
new file mode 100644
index 00000000..5b402f58
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat3-wr.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3[3] dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-rd.shader_test
new file mode 100644
index 00000000..b074b8f8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-rd.shader_test
@@ -0,0 +1,57 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..4e44e53c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-row-rd.shader_test
@@ -0,0 +1,123 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test
new file mode 100644
index 00000000..65fcb343
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-row-wr.shader_test
@@ -0,0 +1,177 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-wr.shader_test
new file mode 100644
index 00000000..f2c32e62
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-col-wr.shader_test
@@ -0,0 +1,76 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test
new file mode 100644
index 00000000..e38e0e8f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-rd.shader_test
@@ -0,0 +1,102 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 expect 33 34 35 36
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 41 42 43 44
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 45 46 47 48
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test
new file mode 100644
index 00000000..efcfee10
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-row-rd.shader_test
@@ -0,0 +1,296 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 33
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 34
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 35
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 36
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 41
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 42
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 43
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 44
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 45
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 46
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 47
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 48
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test
new file mode 100644
index 00000000..8d870133
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-row-wr.shader_test
@@ -0,0 +1,444 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test
new file mode 100644
index 00000000..b5508c92
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-col-wr.shader_test
@@ -0,0 +1,143 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-rd.shader_test
new file mode 100644
index 00000000..35d12153
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-rd.shader_test
@@ -0,0 +1,52 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test
new file mode 100644
index 00000000..4df31eea
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-row-rd.shader_test
@@ -0,0 +1,102 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test
new file mode 100644
index 00000000..10e35489
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-row-wr.shader_test
@@ -0,0 +1,144 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-wr.shader_test
new file mode 100644
index 00000000..7b5d494d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-index-wr.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+    gl_FrontColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-rd.shader_test
new file mode 100644
index 00000000..e5f63045
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-rd.shader_test
@@ -0,0 +1,39 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-row-rd.shader_test
new file mode 100644
index 00000000..2a164071
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-row-rd.shader_test
@@ -0,0 +1,57 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] m = mat4x4[3](
+        mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+        mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+        mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-row-wr.shader_test
new file mode 100644
index 00000000..d7718d5e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-row-wr.shader_test
@@ -0,0 +1,77 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-wr.shader_test
new file mode 100644
index 00000000..e4f81d1b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-array-mat4-wr.shader_test
@@ -0,0 +1,51 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4[3] dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+    gl_FrontColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-rd.shader_test
new file mode 100644
index 00000000..4e9b8bdf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-rd.shader_test
@@ -0,0 +1,44 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..e29bea6b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-row-rd.shader_test
@@ -0,0 +1,58 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-row-wr.shader_test
new file mode 100644
index 00000000..e31bc395
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-row-wr.shader_test
@@ -0,0 +1,74 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-wr.shader_test
new file mode 100644
index 00000000..4e70f6f0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-col-wr.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-rd.shader_test
new file mode 100644
index 00000000..e375eb1f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-rd.shader_test
@@ -0,0 +1,36 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-row-rd.shader_test
new file mode 100644
index 00000000..0f750647
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-row-rd.shader_test
@@ -0,0 +1,44 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-row-wr.shader_test
new file mode 100644
index 00000000..e8438d9b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-row-wr.shader_test
@@ -0,0 +1,56 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-wr.shader_test
new file mode 100644
index 00000000..5117b6a7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat2-wr.shader_test
@@ -0,0 +1,46 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat2x2 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-rd.shader_test
new file mode 100644
index 00000000..9e93244f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-rd.shader_test
@@ -0,0 +1,49 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..46f8da62
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-row-rd.shader_test
@@ -0,0 +1,84 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-row-wr.shader_test
new file mode 100644
index 00000000..e38849c3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-row-wr.shader_test
@@ -0,0 +1,115 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-wr.shader_test
new file mode 100644
index 00000000..2510a7e7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-col-wr.shader_test
@@ -0,0 +1,63 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-rd.shader_test
new file mode 100644
index 00000000..5e7f0bc2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-rd.shader_test
@@ -0,0 +1,36 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-row-rd.shader_test
new file mode 100644
index 00000000..f1e90f1b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-row-rd.shader_test
@@ -0,0 +1,49 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-row-wr.shader_test
new file mode 100644
index 00000000..d059f114
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-row-wr.shader_test
@@ -0,0 +1,64 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-wr.shader_test
new file mode 100644
index 00000000..be579a1a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat3-wr.shader_test
@@ -0,0 +1,46 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat3x3 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-rd.shader_test
new file mode 100644
index 00000000..0cd35930
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..9caeb46c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-row-rd.shader_test
@@ -0,0 +1,120 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-row-wr.shader_test
new file mode 100644
index 00000000..d3459486
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-row-wr.shader_test
@@ -0,0 +1,172 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-wr.shader_test
new file mode 100644
index 00000000..e070e881
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-col-wr.shader_test
@@ -0,0 +1,71 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-rd.shader_test
new file mode 100644
index 00000000..b081a640
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-rd.shader_test
@@ -0,0 +1,36 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-row-rd.shader_test
new file mode 100644
index 00000000..d614f085
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-row-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-row-wr.shader_test
new file mode 100644
index 00000000..21ec3183
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-row-wr.shader_test
@@ -0,0 +1,72 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-wr.shader_test
new file mode 100644
index 00000000..1588eddd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-temp-mat4-wr.shader_test
@@ -0,0 +1,46 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    mat4x4 dst_matrix;
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+    gl_FrontColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+#version 120
+void main() { gl_FragColor = gl_Color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test
new file mode 100644
index 00000000..e54710e6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-col-rd.shader_test
@@ -0,0 +1,50 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..dbe55722
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-col-row-rd.shader_test
@@ -0,0 +1,64 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test
new file mode 100644
index 00000000..0d392bb4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-col-rd.shader_test
@@ -0,0 +1,75 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 expect 9 10
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test
new file mode 100644
index 00000000..39e2bf26
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-col-row-rd.shader_test
@@ -0,0 +1,113 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 9
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test
new file mode 100644
index 00000000..416b8976
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test
new file mode 100644
index 00000000..a5ca8c92
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-index-row-rd.shader_test
@@ -0,0 +1,75 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-rd.shader_test
new file mode 100644
index 00000000..3815d3cd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-rd.shader_test
@@ -0,0 +1,42 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test
new file mode 100644
index 00000000..07f5cd46
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat2-row-rd.shader_test
@@ -0,0 +1,50 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2[3] m = mat2x2[3](
+    mat2x2(1.0, 2.0, 3.0, 4.0),
+    mat2x2(5.0, 6.0, 7.0, 8.0),
+    mat2x2(9.0, 10.0, 11.0, 12.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test
new file mode 100644
index 00000000..368804f7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-col-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..ced6051d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-col-row-rd.shader_test
@@ -0,0 +1,90 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test
new file mode 100644
index 00000000..0198c42a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-col-rd.shader_test
@@ -0,0 +1,90 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 expect 19 20 21
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 25 26 27
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test
new file mode 100644
index 00000000..7490d993
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-col-row-rd.shader_test
@@ -0,0 +1,191 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 19
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 20
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 21
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test
new file mode 100644
index 00000000..4500d127
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test
new file mode 100644
index 00000000..b7d5405c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-index-row-rd.shader_test
@@ -0,0 +1,90 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-rd.shader_test
new file mode 100644
index 00000000..3ad8b6db
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-rd.shader_test
@@ -0,0 +1,42 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test
new file mode 100644
index 00000000..b4731221
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat3-row-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3[3] m = mat3x3[3](
+    mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0),
+    mat3x3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0),
+    mat3x3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test
new file mode 100644
index 00000000..8011a820
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-col-rd.shader_test
@@ -0,0 +1,60 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..d37e46ba
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-col-row-rd.shader_test
@@ -0,0 +1,126 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test
new file mode 100644
index 00000000..821729ef
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-col-rd.shader_test
@@ -0,0 +1,105 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 expect 33 34 35 36
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 41 42 43 44
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 45 46 47 48
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test
new file mode 100644
index 00000000..44d34739
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-col-row-rd.shader_test
@@ -0,0 +1,299 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 33
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 34
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 35
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 36
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 41
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 42
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 43
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 44
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 45
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 46
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 47
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 48
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test
new file mode 100644
index 00000000..74f195d7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test
new file mode 100644
index 00000000..f25e5976
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-index-row-rd.shader_test
@@ -0,0 +1,105 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-rd.shader_test
new file mode 100644
index 00000000..28dd319f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-rd.shader_test
@@ -0,0 +1,42 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test
new file mode 100644
index 00000000..a87f0af2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-array-mat4-row-rd.shader_test
@@ -0,0 +1,60 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4[3] m = mat4x4[3](
+    mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0),
+    mat4x4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0),
+    mat4x4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0));
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-col-rd.shader_test
new file mode 100644
index 00000000..536d7c8b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-col-rd.shader_test
@@ -0,0 +1,44 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..7fb50d43
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-col-row-rd.shader_test
@@ -0,0 +1,58 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-rd.shader_test
new file mode 100644
index 00000000..30703ad0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-rd.shader_test
@@ -0,0 +1,36 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-row-rd.shader_test
new file mode 100644
index 00000000..178bc414
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat2-row-rd.shader_test
@@ -0,0 +1,44 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat2x2 m = mat2x2(1.0, 2.0, 3.0, 4.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-col-rd.shader_test
new file mode 100644
index 00000000..c9bc3b73
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-col-rd.shader_test
@@ -0,0 +1,49 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..00d3d707
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-col-row-rd.shader_test
@@ -0,0 +1,84 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-rd.shader_test
new file mode 100644
index 00000000..9b46f4f1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-rd.shader_test
@@ -0,0 +1,36 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-row-rd.shader_test
new file mode 100644
index 00000000..ed6692ad
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat3-row-rd.shader_test
@@ -0,0 +1,49 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat3x3 m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-col-rd.shader_test
new file mode 100644
index 00000000..745a1220
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-col-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..1df828b4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-col-row-rd.shader_test
@@ -0,0 +1,120 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-rd.shader_test
new file mode 100644
index 00000000..302cc257
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-rd.shader_test
@@ -0,0 +1,36 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-row-rd.shader_test
new file mode 100644
index 00000000..2e6e5d90
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-uniform-mat4-row-rd.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+uniform mat4x4 m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+varying vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-rd.shader_test
new file mode 100644
index 00000000..9c3a8415
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-rd.shader_test
@@ -0,0 +1,63 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..6d14f4bf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-row-rd.shader_test
@@ -0,0 +1,77 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test
new file mode 100644
index 00000000..9843980e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-row-wr.shader_test
@@ -0,0 +1,90 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-wr.shader_test
new file mode 100644
index 00000000..8903c222
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-col-wr.shader_test
@@ -0,0 +1,70 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test
new file mode 100644
index 00000000..e18b2f53
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-rd.shader_test
@@ -0,0 +1,88 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 expect 5 6
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 expect 9 10
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test
new file mode 100644
index 00000000..7a6ecd29
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-row-rd.shader_test
@@ -0,0 +1,126 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 5
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 9
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test
new file mode 100644
index 00000000..cd068d3c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-row-wr.shader_test
@@ -0,0 +1,161 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 45 20 10 10
+probe rgb 50 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 85 20 10 10
+probe rgb 90 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test
new file mode 100644
index 00000000..51755f35
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-col-wr.shader_test
@@ -0,0 +1,105 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 45 5 10 10
+probe rgb 50 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 85 5 10 10
+probe rgb 90 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-rd.shader_test
new file mode 100644
index 00000000..0e39c390
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-rd.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 expect 11 12
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test
new file mode 100644
index 00000000..ecffc136
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-row-rd.shader_test
@@ -0,0 +1,88 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 11
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 12
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test
new file mode 100644
index 00000000..0064b114
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-row-wr.shader_test
@@ -0,0 +1,107 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 100 20 10 10
+probe rgb 105 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-wr.shader_test
new file mode 100644
index 00000000..2928ae82
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-index-wr.shader_test
@@ -0,0 +1,78 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 100 5 10 10
+probe rgb 105 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-rd.shader_test
new file mode 100644
index 00000000..a9f3feb9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 7 8
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-row-rd.shader_test
new file mode 100644
index 00000000..19661fea
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-row-rd.shader_test
@@ -0,0 +1,63 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat2(1.0, 2.0, 3.0, 4.0);
+    m[1] = mat2(5.0, 6.0, 7.0, 8.0);
+    m[2] = mat2(9.0, 10.0, 11.0, 12.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat2x2[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 7
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-row-wr.shader_test
new file mode 100644
index 00000000..67bfa34b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-row-wr.shader_test
@@ -0,0 +1,72 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-wr.shader_test
new file mode 100644
index 00000000..01e3df10
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat2-wr.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat2x2[3](mat2x2(0.0), mat2x2(0.0), mat2x2(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int index;
+uniform int col;
+uniform vec2 value;
+varying mat2x2[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-rd.shader_test
new file mode 100644
index 00000000..4a522a2c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-rd.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..f5a694cf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-row-rd.shader_test
@@ -0,0 +1,103 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test
new file mode 100644
index 00000000..0f18fe15
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-row-wr.shader_test
@@ -0,0 +1,131 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-wr.shader_test
new file mode 100644
index 00000000..7c5fe6d4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-col-wr.shader_test
@@ -0,0 +1,78 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test
new file mode 100644
index 00000000..769137c0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-rd.shader_test
@@ -0,0 +1,103 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 expect 10 11 12
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 16 17 18
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 expect 19 20 21
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 25 26 27
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test
new file mode 100644
index 00000000..adb50a40
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-row-rd.shader_test
@@ -0,0 +1,204 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 10
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 11
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 12
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 16
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 17
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 18
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 19
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 20
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 21
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test
new file mode 100644
index 00000000..0c283090
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-row-wr.shader_test
@@ -0,0 +1,284 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 60 20 10 10
+probe rgb 65 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 60 35 10 10
+probe rgb 65 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 115 20 10 10
+probe rgb 120 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 115 35 10 10
+probe rgb 120 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test
new file mode 100644
index 00000000..23e87f70
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-col-wr.shader_test
@@ -0,0 +1,129 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 60 5 10 10
+probe rgb 65 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 115 5 10 10
+probe rgb 120 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-rd.shader_test
new file mode 100644
index 00000000..4e320a0e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-rd.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 expect 22 23 24
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test
new file mode 100644
index 00000000..1e1871ec
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-row-rd.shader_test
@@ -0,0 +1,103 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 22
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 23
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 24
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test
new file mode 100644
index 00000000..3f403739
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-row-wr.shader_test
@@ -0,0 +1,131 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 130 20 10 10
+probe rgb 135 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 130 35 10 10
+probe rgb 135 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-wr.shader_test
new file mode 100644
index 00000000..2c14a6fb
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-index-wr.shader_test
@@ -0,0 +1,78 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 130 5 10 10
+probe rgb 135 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-rd.shader_test
new file mode 100644
index 00000000..70941ebc
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 13 14 15
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-row-rd.shader_test
new file mode 100644
index 00000000..58a6f47d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-row-rd.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+    m[1] = mat3(10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0);
+    m[2] = mat3(19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat3x3[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 13
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-row-wr.shader_test
new file mode 100644
index 00000000..df32fb8e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-row-wr.shader_test
@@ -0,0 +1,80 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-wr.shader_test
new file mode 100644
index 00000000..c57fb29c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat3-wr.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat3x3[3](mat3x3(0.0), mat3x3(0.0), mat3x3(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int index;
+uniform int col;
+uniform vec3 value;
+varying mat3x3[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-rd.shader_test
new file mode 100644
index 00000000..35b6edd5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-rd.shader_test
@@ -0,0 +1,73 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..ef73b498
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-row-rd.shader_test
@@ -0,0 +1,139 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test
new file mode 100644
index 00000000..ebe2f395
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-row-wr.shader_test
@@ -0,0 +1,188 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col][row] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-wr.shader_test
new file mode 100644
index 00000000..0918e208
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-col-wr.shader_test
@@ -0,0 +1,86 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][col] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test
new file mode 100644
index 00000000..276ff3b8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-rd.shader_test
@@ -0,0 +1,118 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 expect 17 18 19 20
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 25 26 27 28
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 29 30 31 32
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 expect 33 34 35 36
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 41 42 43 44
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 45 46 47 48
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test
new file mode 100644
index 00000000..265bcf2a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-row-rd.shader_test
@@ -0,0 +1,312 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform float expect 17
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 18
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 19
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 20
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 25
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 26
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 27
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 28
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 29
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 30
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 31
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 32
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform float expect 33
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 34
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 35
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 36
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 41
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 42
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 43
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 44
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 45
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 46
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 47
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 48
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test
new file mode 100644
index 00000000..8b865f09
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-row-wr.shader_test
@@ -0,0 +1,455 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col][row] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 75 20 10 10
+probe rgb 80 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 75 35 10 10
+probe rgb 80 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 75 50 10 10
+probe rgb 80 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 105 20 10 10
+probe rgb 110 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 105 35 10 10
+probe rgb 110 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 105 50 10 10
+probe rgb 110 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 120 20 10 10
+probe rgb 125 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 120 35 10 10
+probe rgb 125 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 120 50 10 10
+probe rgb 125 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 145 20 10 10
+probe rgb 150 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 145 35 10 10
+probe rgb 150 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 145 50 10 10
+probe rgb 150 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 175 20 10 10
+probe rgb 180 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 175 35 10 10
+probe rgb 180 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 175 50 10 10
+probe rgb 180 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 190 20 10 10
+probe rgb 195 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 190 35 10 10
+probe rgb 195 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 190 50 10 10
+probe rgb 195 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test
new file mode 100644
index 00000000..f045a3bf
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-col-wr.shader_test
@@ -0,0 +1,153 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][col] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 75 5 10 10
+probe rgb 80 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 105 5 10 10
+probe rgb 110 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 120 5 10 10
+probe rgb 125 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 145 5 10 10
+probe rgb 150 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 175 5 10 10
+probe rgb 180 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 190 5 10 10
+probe rgb 195 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-rd.shader_test
new file mode 100644
index 00000000..983d1dff
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-rd.shader_test
@@ -0,0 +1,68 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 expect 37 38 39 40
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test
new file mode 100644
index 00000000..118b865f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-row-rd.shader_test
@@ -0,0 +1,118 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[index][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int index;
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[index][1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform float expect 37
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 38
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 39
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 40
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test
new file mode 100644
index 00000000..5baaf329
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-row-wr.shader_test
@@ -0,0 +1,155 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1][row] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int index 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
+
+uniform int index 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 160 20 10 10
+probe rgb 165 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 160 35 10 10
+probe rgb 165 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 160 50 10 10
+probe rgb 165 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-wr.shader_test
new file mode 100644
index 00000000..351238bd
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-index-wr.shader_test
@@ -0,0 +1,78 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[index] = src_matrix;
+    dst_matrix[index][1] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[index] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int index 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int index 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int index 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 160 5 10 10
+probe rgb 165 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-rd.shader_test
new file mode 100644
index 00000000..47cfcf99
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-rd.shader_test
@@ -0,0 +1,55 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 21 22 23 24
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-row-rd.shader_test
new file mode 100644
index 00000000..4fa8525a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-row-rd.shader_test
@@ -0,0 +1,73 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m[0] = mat4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+    m[1] = mat4(17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0);
+    m[2] = mat4(33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat4x4[3] m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 21
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 22
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 23
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 24
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-row-wr.shader_test
new file mode 100644
index 00000000..1374bce0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-row-wr.shader_test
@@ -0,0 +1,88 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1][row] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 90 20 10 10
+probe rgb 95 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 90 35 10 10
+probe rgb 95 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 90 50 10 10
+probe rgb 95 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-wr.shader_test
new file mode 100644
index 00000000..3eb0a508
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-array-mat4-wr.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    dst_matrix = mat4x4[3](mat4x4(0.0), mat4x4(0.0), mat4x4(0.0));
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     *
+     * NOTE: This test assumes that reads of arrays using non-constant
+     * indicies works correctly.  If reads and writes happen to fail in an
+     * identical manner, this test may give false positives.
+     */
+    dst_matrix[1] = src_matrix;
+    dst_matrix[1][1] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int index;
+uniform int col;
+uniform vec4 value;
+varying mat4x4[3] dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix[1] * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 90 5 10 10
+probe rgb 95 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-rd.shader_test
new file mode 100644
index 00000000..fa2b2707
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-rd.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 expect 1 2
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-row-rd.shader_test
new file mode 100644
index 00000000..d475dbde
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-row-rd.shader_test
@@ -0,0 +1,75 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-row-wr.shader_test
new file mode 100644
index 00000000..93f37707
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-row-wr.shader_test
@@ -0,0 +1,83 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 0.861223395812970 0.603473877011433 0.891622340451180
+uniform float value 0.241498998195656
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 666.0 0.603473877011433 0.891622340451180
+uniform float value 0.861223395812970
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-wr.shader_test
new file mode 100644
index 00000000..d5c79ba7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-col-wr.shader_test
@@ -0,0 +1,63 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 666.0 777.0 0.603473877011433 0.891622340451180
+uniform vec2 value 0.241498998195656 0.861223395812970
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-rd.shader_test
new file mode 100644
index 00000000..c7f1827c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-rd.shader_test
@@ -0,0 +1,53 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec2 expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 expect 3 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-row-rd.shader_test
new file mode 100644
index 00000000..4fccf9ce
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-row-rd.shader_test
@@ -0,0 +1,61 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat2x2(1.0, 2.0, 3.0, 4.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat2x2 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 3
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 4
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-row-wr.shader_test
new file mode 100644
index 00000000..773ffc5e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-row-wr.shader_test
@@ -0,0 +1,65 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 0.891622340451180
+uniform float value 0.603473877011433
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 0.603473877011433 666.0
+uniform float value 0.891622340451180
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-wr.shader_test
new file mode 100644
index 00000000..e07316b8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat2-wr.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+}
+
+[fragment shader]
+uniform mat2x2 src_matrix;
+uniform vec2 v;
+uniform vec2 expect;
+uniform int col;
+uniform vec2 value;
+varying mat2x2 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec2 v 0.803161418975390 0.852987140792140
+uniform vec2 expect 0.708718134966688 1.452243795483797
+uniform mat2x2 src_matrix 0.241498998195656 0.861223395812970 666.0 777.0
+uniform vec2 value 0.603473877011433 0.891622340451180
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-rd.shader_test
new file mode 100644
index 00000000..3ad7ccef
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-rd.shader_test
@@ -0,0 +1,66 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 expect 1 2 3
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 expect 7 8 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-row-rd.shader_test
new file mode 100644
index 00000000..ff386787
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-row-rd.shader_test
@@ -0,0 +1,101 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 7
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 8
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 9
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-row-wr.shader_test
new file mode 100644
index 00000000..b1c04006
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-row-wr.shader_test
@@ -0,0 +1,124 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.493944462129466
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 666.0 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.722190133917966
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 666.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.239853948232558
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 0.511303112962423 0.270815003356504
+uniform float value 0.850846377186973
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 666.0 0.270815003356504
+uniform float value 0.511303112962423
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 666.0
+uniform float value 0.270815003356504
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-wr.shader_test
new file mode 100644
index 00000000..00af416a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-col-wr.shader_test
@@ -0,0 +1,71 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 666.0 777.0 888.0 0.550143078409278 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.493944462129466 0.722190133917966 0.239853948232558
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 0.467616286531193 666.0 777.0 888.0
+uniform vec3 value 0.850846377186973 0.511303112962423 0.270815003356504
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-rd.shader_test
new file mode 100644
index 00000000..dd663ab4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-rd.shader_test
@@ -0,0 +1,53 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec3 expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 expect 4 5 6
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-row-rd.shader_test
new file mode 100644
index 00000000..b76f8ca6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-row-rd.shader_test
@@ -0,0 +1,66 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat3x3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat3x3 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 4
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 5
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 6
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-row-wr.shader_test
new file mode 100644
index 00000000..1addf038
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-row-wr.shader_test
@@ -0,0 +1,73 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 0.591962645398579 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.550143078409278
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 666.0 0.467616286531193 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.591962645398579
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 0.550143078409278 0.591962645398579 666.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform float value 0.467616286531193
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-wr.shader_test
new file mode 100644
index 00000000..1c5f63e5
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat3-wr.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+}
+
+[fragment shader]
+uniform mat3x3 src_matrix;
+uniform vec3 v;
+uniform vec3 expect;
+uniform int col;
+uniform vec3 value;
+varying mat3x3 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec3 v 0.681652305322399 0.210426138878113 0.185916924650237
+uniform vec3 expect 0.610649606928364 0.711906885823636 0.312244778977868
+uniform mat3x3 src_matrix 0.493944462129466 0.722190133917966 0.239853948232558 666.0 777.0 888.0 0.850846377186973 0.511303112962423 0.270815003356504
+uniform vec3 value 0.550143078409278 0.591962645398579 0.467616286531193
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-rd.shader_test
new file mode 100644
index 00000000..9a26d661
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-rd.shader_test
@@ -0,0 +1,71 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[col] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[col] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 expect 1 2 3 4
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 expect 9 10 11 12
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 expect 13 14 15 16
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-row-rd.shader_test
new file mode 100644
index 00000000..f21244e9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-row-rd.shader_test
@@ -0,0 +1,137 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[col][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int col;
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[col][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform float expect 1
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 2
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 3
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 4
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform float expect 9
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 10
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 11
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 12
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform float expect 13
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 14
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 15
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 16
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-row-wr.shader_test
new file mode 100644
index 00000000..9c16d067
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-row-wr.shader_test
@@ -0,0 +1,181 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col][row] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.922040144261674
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 666.0 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.158053783109488
+draw rect 5 20 10 10
+probe rgb 10 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 666.0 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.357016429866574
+draw rect 5 35 10 10
+probe rgb 10 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 666.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.836368810383957
+draw rect 5 50 10 10
+probe rgb 10 55 0.0 1.0 0.0
+
+uniform int col 1
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
+
+uniform int col 2
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.350720358904176
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 666.0 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.912192627475775
+draw rect 35 20 10 10
+probe rgb 40 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 666.0 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.688544081259531
+draw rect 35 35 10 10
+probe rgb 40 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 666.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.913891056231967
+draw rect 35 50 10 10
+probe rgb 40 55 0.0 1.0 0.0
+
+uniform int col 3
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.442058176039301
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 666.0 0.365674411003021 0.879197364462782
+uniform float value 0.829835836794679
+draw rect 50 20 10 10
+probe rgb 55 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 666.0 0.879197364462782
+uniform float value 0.365674411003021
+draw rect 50 35 10 10
+probe rgb 55 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 666.0
+uniform float value 0.879197364462782
+draw rect 50 50 10 10
+probe rgb 55 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-wr.shader_test
new file mode 100644
index 00000000..fbb374d6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-col-wr.shader_test
@@ -0,0 +1,79 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[col] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int col 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 666.0 777.0 888.0 999.0 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957
+draw rect 5 5 10 10
+probe rgb 10 10 0.0 1.0 0.0
+
+uniform int col 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int col 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 666.0 777.0 888.0 999.0 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967
+draw rect 35 5 10 10
+probe rgb 40 10 0.0 1.0 0.0
+
+uniform int col 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 666.0 777.0 888.0 999.0
+uniform vec4 value 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+draw rect 50 5 10 10
+probe rgb 55 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-rd.shader_test
new file mode 100644
index 00000000..175bed8e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-rd.shader_test
@@ -0,0 +1,53 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform vec4 expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 expect 5 6 7 8
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-row-rd.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-row-rd.shader_test
new file mode 100644
index 00000000..ea05c6ab
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-row-rd.shader_test
@@ -0,0 +1,71 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-read.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+    m = mat4x4(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
+
+    /* From page 23 (page 30 of the PDF) of the GLSL 1.10 spec:
+     *
+     *     "A vertex shader may also read varying variables, getting back the
+     *     same values it has written. Reading a varying variable in a vertex
+     *     shader returns undefined values if it is read before being
+     *     written."
+     */
+    color = (m[1][row] == expect)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[fragment shader]
+uniform int row;
+uniform float expect;
+varying mat4x4 m;
+varying vec4 color;
+
+void main()
+{
+    /* There is some trickery here.  The fragment shader has to actually use
+     * the varyings generated by the vertex shader, or the compiler (more
+     * likely the linker) might demote the varying outputs to just be vertex
+     * shader global variables.  Since the point of the test is the vertex
+     * shader reading from a varying, that would defeat the test.
+     */
+    gl_FragColor = (m[1][row] == expect)
+        ? color : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform float expect 5
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform float expect 6
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform float expect 7
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform float expect 8
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-row-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-row-wr.shader_test
new file mode 100644
index 00000000..2ed0d6c3
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-row-wr.shader_test
@@ -0,0 +1,81 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1][row] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int row;
+uniform int col;
+uniform float value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform int row 0
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 0.171634921595771 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.560251913703792
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
+
+uniform int row 1
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 666.0 0.602494709909111 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.171634921595771
+draw rect 20 20 10 10
+probe rgb 25 25 0.0 1.0 0.0
+
+uniform int row 2
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 666.0 0.693273570571311 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.602494709909111
+draw rect 20 35 10 10
+probe rgb 25 40 0.0 1.0 0.0
+
+uniform int row 3
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 0.560251913703792 0.171634921595771 0.602494709909111 666.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform float value 0.693273570571311
+draw rect 20 50 10 10
+probe rgb 25 55 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-wr.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-wr.shader_test
new file mode 100644
index 00000000..a55c8ba1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/variable-indexing/vs-varying-mat4-wr.shader_test
@@ -0,0 +1,54 @@
+# Test generated by:
+# ../../../glsl-1.10/variable-index-write.sh 1.20
+
+[require]
+GLSL >= 1.20
+
+[vertex shader]
+#version 120
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+
+    /* Patch the supplied matrix with the supplied value.  If the resulting
+     * matrix is correct, it will transform the input vector to the expected
+     * value.  Verify that the distance between the result and the expected
+     * vector is less than epsilon.
+     */
+    dst_matrix = src_matrix;
+    dst_matrix[1] = value;
+}
+
+[fragment shader]
+uniform mat4x4 src_matrix;
+uniform vec4 v;
+uniform vec4 expect;
+uniform int col;
+uniform vec4 value;
+varying mat4x4 dst_matrix;
+
+void main()
+{
+    gl_FragColor = (distance(dst_matrix * v, expect) < 1e-6)
+        ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.5 0.5 0.5 0.5
+clear
+ortho
+
+uniform vec4 v 0.0394868046587045 0.8922408276905568 0.3337495624366961 0.8732295730825839
+uniform vec4 expect 1.03935908892461 1.18846180713529 1.10078681232072 1.72434439561820
+uniform mat4x4 src_matrix 0.922040144261674 0.158053783109488 0.357016429866574 0.836368810383957 666.0 777.0 888.0 999.0 0.350720358904176 0.912192627475775 0.688544081259531 0.913891056231967 0.442058176039301 0.829835836794679 0.365674411003021 0.879197364462782
+uniform vec4 value 0.560251913703792 0.171634921595771 0.602494709909111 0.693273570571311
+draw rect 20 5 10 10
+probe rgb 25 10 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-all-equal-bool-array.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-all-equal-bool-array.shader_test
new file mode 100644
index 00000000..c9c1e6f1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-all-equal-bool-array.shader_test
@@ -0,0 +1,39 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+varying vec4 color;
+
+uniform bool[2] ub = bool[2](bool(0), bool(1));
+
+void main()
+{
+  if (ub == bool[2](bool(1), bool(1))) {
+    color = vec4(1, 0, 0, 1);
+  } else {
+    color = vec4(0, 1, 0, 1);
+  }
+
+  gl_Position = vertex;
+}
+
+[fragment shader]
+
+varying vec4 color;
+
+void main()
+{
+  gl_FragColor = color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgb 0 1 0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-assign-varied-struct.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-assign-varied-struct.shader_test
new file mode 100644
index 00000000..e275bba9
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-assign-varied-struct.shader_test
@@ -0,0 +1,39 @@
+# Test initialization of an array of structures where the elements of
+# the structure do not all have the same vector size.
+#
+# This test reproduces the problem described in
+# https://bugs.freedesktop.org/show_bug.cgi?id=40865#c9.
+
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+void main(void)
+{
+    float x = 3.0;
+    struct s { float f; vec3 v; };
+    s a[1]=s[](s(x,vec3(x)));
+    if (a[0].f==3.0)
+      gl_FrontColor = vec4(0.0, 1.0, 0.0, 1.0); // green
+    else
+      gl_FrontColor = vec4(1.0, 0.0, 0.0, 1.0); // red
+    gl_Position = vertex;
+}
+
+[fragment shader]
+void main(void)
+{
+    gl_FragColor = gl_Color;
+}
+
+[test]
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2-ivec.shader_test
new file mode 100644
index 00000000..c02a01de
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2-ivec.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec2 r = ivec2(4, 5);
+uniform mat2 expected = mat2(8, 12, 10, 15);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2.shader_test
new file mode 100644
index 00000000..44434694
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2.shader_test
@@ -0,0 +1,37 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec2 c = vec2(2, 3);
+const vec2 r = vec2(4, 5);
+uniform mat2 expected = mat2(8, 12, 10, 15);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x2-ivec.shader_test
new file mode 100644
index 00000000..b45e696e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x2-ivec.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec2 r = ivec2(4, 5);
+uniform mat2x2 expected = mat2x2(8, 12, 10, 15);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x2.shader_test
new file mode 100644
index 00000000..61a26e47
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x2.shader_test
@@ -0,0 +1,37 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec2 c = vec2(2, 3);
+const vec2 r = vec2(4, 5);
+uniform mat2x2 expected = mat2x2(8, 12, 10, 15);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x3-ivec.shader_test
new file mode 100644
index 00000000..49210b24
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x3-ivec.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec2 r = ivec2(5, 6);
+uniform mat2x3 expected = mat2x3(10, 15, 20, 12, 18, 24);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x3.shader_test
new file mode 100644
index 00000000..54c9231e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x3.shader_test
@@ -0,0 +1,39 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec2 r = vec2(5, 6);
+uniform mat2x3 expected = mat2x3(10, 15, 20, 12, 18, 24);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x4-ivec.shader_test
new file mode 100644
index 00000000..7d2daed2
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x4-ivec.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec2 r = ivec2(6, 7);
+uniform mat2x4 expected = mat2x4(12, 18, 24, 30, 14, 21, 28, 35);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x4.shader_test
new file mode 100644
index 00000000..d7098643
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat2x4.shader_test
@@ -0,0 +1,39 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec2 r = vec2(6, 7);
+uniform mat2x4 expected = mat2x4(12, 18, 24, 30, 14, 21, 28, 35);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3-ivec.shader_test
new file mode 100644
index 00000000..0ca67e25
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3-ivec.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec3 r = ivec3(5, 6, 7);
+uniform mat3 expected = mat3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3.shader_test
new file mode 100644
index 00000000..ba727bce
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3.shader_test
@@ -0,0 +1,37 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec3 r = vec3(5, 6, 7);
+uniform mat3 expected = mat3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x2-ivec.shader_test
new file mode 100644
index 00000000..7af7ce1d
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x2-ivec.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec3 r = ivec3(4, 5, 6);
+uniform mat3x2 expected = mat3x2(8, 12, 10, 15, 12, 18);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x2.shader_test
new file mode 100644
index 00000000..894dfb41
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x2.shader_test
@@ -0,0 +1,39 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec2 c = vec2(2, 3);
+const vec3 r = vec3(4, 5, 6);
+uniform mat3x2 expected = mat3x2(8, 12, 10, 15, 12, 18);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x3-ivec.shader_test
new file mode 100644
index 00000000..fa11bd0e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x3-ivec.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec3 r = ivec3(5, 6, 7);
+uniform mat3x3 expected = mat3x3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x3.shader_test
new file mode 100644
index 00000000..c01f50ed
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x3.shader_test
@@ -0,0 +1,37 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec3 r = vec3(5, 6, 7);
+uniform mat3x3 expected = mat3x3(10, 15, 20, 12, 18, 24, 14, 21, 28);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x4-ivec.shader_test
new file mode 100644
index 00000000..41565eb7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x4-ivec.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec3 r = ivec3(6, 7, 8);
+uniform mat3x4 expected = mat3x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x4.shader_test
new file mode 100644
index 00000000..734d3513
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat3x4.shader_test
@@ -0,0 +1,39 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec3 r = vec3(6, 7, 8);
+uniform mat3x4 expected = mat3x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4-ivec.shader_test
new file mode 100644
index 00000000..7c634497
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4-ivec.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec4 r = ivec4(6, 7, 8, 9);
+uniform mat4 expected = mat4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4.shader_test
new file mode 100644
index 00000000..df346d47
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4.shader_test
@@ -0,0 +1,37 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec4 r = vec4(6, 7, 8, 9);
+uniform mat4 expected = mat4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x2-ivec.shader_test
new file mode 100644
index 00000000..9592645f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x2-ivec.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec2 c = ivec2(2, 3);
+const ivec4 r = ivec4(4, 5, 6, 7);
+uniform mat4x2 expected = mat4x2(8, 12, 10, 15, 12, 18, 14, 21);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x2.shader_test
new file mode 100644
index 00000000..2e37c9f1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x2.shader_test
@@ -0,0 +1,39 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec2 c = vec2(2, 3);
+const vec4 r = vec4(4, 5, 6, 7);
+uniform mat4x2 expected = mat4x2(8, 12, 10, 15, 12, 18, 14, 21);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x3-ivec.shader_test
new file mode 100644
index 00000000..39dc2ad0
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x3-ivec.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec3 c = ivec3(2, 3, 4);
+const ivec4 r = ivec4(5, 6, 7, 8);
+uniform mat4x3 expected = mat4x3(10, 15, 20, 12, 18, 24, 14, 21, 28, 16, 24, 32);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x3.shader_test
new file mode 100644
index 00000000..61493be6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x3.shader_test
@@ -0,0 +1,39 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec3 c = vec3(2, 3, 4);
+const vec4 r = vec4(5, 6, 7, 8);
+uniform mat4x3 expected = mat4x3(10, 15, 20, 12, 18, 24, 14, 21, 28, 16, 24, 32);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x4-ivec.shader_test
new file mode 100644
index 00000000..cad7a261
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x4-ivec.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+
+const ivec4 c = ivec4(2, 3, 4, 5);
+const ivec4 r = ivec4(6, 7, 8, 9);
+uniform mat4x4 expected = mat4x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x4.shader_test
new file mode 100644
index 00000000..9c7ca0d1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-const-mat4x4.shader_test
@@ -0,0 +1,37 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+
+const vec4 c = vec4(2, 3, 4, 5);
+const vec4 r = vec4(6, 7, 8, 9);
+uniform mat4x4 expected = mat4x4(12, 18, 24, 30, 14, 21, 28, 35, 16, 24, 32, 40, 18, 27, 36, 45);
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2-ivec.shader_test
new file mode 100644
index 00000000..78e20f90
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2-ivec.shader_test
@@ -0,0 +1,77 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec2 r;
+uniform mat2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2.shader_test
new file mode 100644
index 00000000..00d6b55e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec2 c;
+uniform vec2 r;
+uniform mat2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x2-ivec.shader_test
new file mode 100644
index 00000000..5feb409b
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x2-ivec.shader_test
@@ -0,0 +1,77 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec2 r;
+uniform mat2x2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x2.shader_test
new file mode 100644
index 00000000..88bb5404
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x2.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec2 c;
+uniform vec2 r;
+uniform mat2x2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec2 r  4 5
+uniform mat2x2 expected  8 12 10 15
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec2 r  5 6
+uniform mat2x2 expected  15 20 18 24
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec2 r  6 7
+uniform mat2x2 expected  24 30 28 35
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec2 r  7 8
+uniform mat2x2 expected  35 42 40 48
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x3-ivec.shader_test
new file mode 100644
index 00000000..dc6682c4
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x3-ivec.shader_test
@@ -0,0 +1,79 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec2 r;
+uniform mat2x3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec2 r  5 6
+uniform mat2x3 expected  10 15 20 12 18 24
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec2 r  6 7
+uniform mat2x3 expected  18 24 30 21 28 35
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec2 r  7 8
+uniform mat2x3 expected  28 35 42 32 40 48
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec2 r  8 9
+uniform mat2x3 expected  40 48 56 45 54 63
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x3.shader_test
new file mode 100644
index 00000000..8cbb5172
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x3.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec3 c;
+uniform vec2 r;
+uniform mat2x3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec2 r  5 6
+uniform mat2x3 expected  10 15 20 12 18 24
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec2 r  6 7
+uniform mat2x3 expected  18 24 30 21 28 35
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec2 r  7 8
+uniform mat2x3 expected  28 35 42 32 40 48
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec2 r  8 9
+uniform mat2x3 expected  40 48 56 45 54 63
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x4-ivec.shader_test
new file mode 100644
index 00000000..9ced3cee
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x4-ivec.shader_test
@@ -0,0 +1,79 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec2 r;
+uniform mat2x4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec2 r  6 7
+uniform mat2x4 expected  12 18 24 30 14 21 28 35
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec2 r  7 8
+uniform mat2x4 expected  21 28 35 42 24 32 40 48
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec2 r  8 9
+uniform mat2x4 expected  32 40 48 56 36 45 54 63
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec2 r  9 10
+uniform mat2x4 expected  45 54 63 72 50 60 70 80
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x4.shader_test
new file mode 100644
index 00000000..a7645321
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat2x4.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix2x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec4 c;
+uniform vec2 r;
+uniform mat2x4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat2x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec2 r  6 7
+uniform mat2x4 expected  12 18 24 30 14 21 28 35
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec2 r  7 8
+uniform mat2x4 expected  21 28 35 42 24 32 40 48
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec2 r  8 9
+uniform mat2x4 expected  32 40 48 56 36 45 54 63
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec2 r  9 10
+uniform mat2x4 expected  45 54 63 72 50 60 70 80
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3-ivec.shader_test
new file mode 100644
index 00000000..b45d27db
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3-ivec.shader_test
@@ -0,0 +1,77 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec3 r;
+uniform mat3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3.shader_test
new file mode 100644
index 00000000..16fc0a87
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec3 c;
+uniform vec3 r;
+uniform mat3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x2-ivec.shader_test
new file mode 100644
index 00000000..e577dfc1
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x2-ivec.shader_test
@@ -0,0 +1,79 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec3 r;
+uniform mat3x2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec3 r  4 5 6
+uniform mat3x2 expected  8 12 10 15 12 18
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec3 r  5 6 7
+uniform mat3x2 expected  15 20 18 24 21 28
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec3 r  6 7 8
+uniform mat3x2 expected  24 30 28 35 32 40
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec3 r  7 8 9
+uniform mat3x2 expected  35 42 40 48 45 54
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x2.shader_test
new file mode 100644
index 00000000..e7d332da
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x2.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec2 c;
+uniform vec3 r;
+uniform mat3x2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec3 r  4 5 6
+uniform mat3x2 expected  8 12 10 15 12 18
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec3 r  5 6 7
+uniform mat3x2 expected  15 20 18 24 21 28
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec3 r  6 7 8
+uniform mat3x2 expected  24 30 28 35 32 40
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec3 r  7 8 9
+uniform mat3x2 expected  35 42 40 48 45 54
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x3-ivec.shader_test
new file mode 100644
index 00000000..2106548c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x3-ivec.shader_test
@@ -0,0 +1,77 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec3 r;
+uniform mat3x3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x3.shader_test
new file mode 100644
index 00000000..863544d6
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x3.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec3 c;
+uniform vec3 r;
+uniform mat3x3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec3 r  5 6 7
+uniform mat3x3 expected  10 15 20 12 18 24 14 21 28
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec3 r  6 7 8
+uniform mat3x3 expected  18 24 30 21 28 35 24 32 40
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec3 r  7 8 9
+uniform mat3x3 expected  28 35 42 32 40 48 36 45 54
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec3 r  8 9 10
+uniform mat3x3 expected  40 48 56 45 54 63 50 60 70
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x4-ivec.shader_test
new file mode 100644
index 00000000..f06744ed
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x4-ivec.shader_test
@@ -0,0 +1,79 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec3 r;
+uniform mat3x4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec3 r  6 7 8
+uniform mat3x4 expected  12 18 24 30 14 21 28 35 16 24 32 40
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec3 r  7 8 9
+uniform mat3x4 expected  21 28 35 42 24 32 40 48 27 36 45 54
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec3 r  8 9 10
+uniform mat3x4 expected  32 40 48 56 36 45 54 63 40 50 60 70
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec3 r  9 10 11
+uniform mat3x4 expected  45 54 63 72 50 60 70 80 55 66 77 88
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x4.shader_test
new file mode 100644
index 00000000..7779535c
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat3x4.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix3x4fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec4 c;
+uniform vec3 r;
+uniform mat3x4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat3x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec3 r  6 7 8
+uniform mat3x4 expected  12 18 24 30 14 21 28 35 16 24 32 40
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec3 r  7 8 9
+uniform mat3x4 expected  21 28 35 42 24 32 40 48 27 36 45 54
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec3 r  8 9 10
+uniform mat3x4 expected  32 40 48 56 36 45 54 63 40 50 60 70
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec3 r  9 10 11
+uniform mat3x4 expected  45 54 63 72 50 60 70 80 55 66 77 88
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4-ivec.shader_test
new file mode 100644
index 00000000..df564a1f
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4-ivec.shader_test
@@ -0,0 +1,77 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec4 r;
+uniform mat4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4.shader_test
new file mode 100644
index 00000000..f27e5754
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec4 c;
+uniform vec4 r;
+uniform mat4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x2-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x2-ivec.shader_test
new file mode 100644
index 00000000..3aa1565a
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x2-ivec.shader_test
@@ -0,0 +1,79 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec2 c;
+uniform ivec4 r;
+uniform mat4x2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec2 c  2 3
+uniform ivec4 r  4 5 6 7
+uniform mat4x2 expected  8 12 10 15 12 18 14 21
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec2 c  3 4
+uniform ivec4 r  5 6 7 8
+uniform mat4x2 expected  15 20 18 24 21 28 24 32
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec2 c  4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x2 expected  24 30 28 35 32 40 36 45
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec2 c  5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x2 expected  35 42 40 48 45 54 50 60
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x2.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x2.shader_test
new file mode 100644
index 00000000..f16ad09e
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x2.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x2fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec2 c;
+uniform vec4 r;
+uniform mat4x2 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x2 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec2 c  2 3
+uniform vec4 r  4 5 6 7
+uniform mat4x2 expected  8 12 10 15 12 18 14 21
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec2 c  3 4
+uniform vec4 r  5 6 7 8
+uniform mat4x2 expected  15 20 18 24 21 28 24 32
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec2 c  4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x2 expected  24 30 28 35 32 40 36 45
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec2 c  5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x2 expected  35 42 40 48 45 54 50 60
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x3-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x3-ivec.shader_test
new file mode 100644
index 00000000..30eb3ad7
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x3-ivec.shader_test
@@ -0,0 +1,79 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec3 c;
+uniform ivec4 r;
+uniform mat4x3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec3 c  2 3 4
+uniform ivec4 r  5 6 7 8
+uniform mat4x3 expected  10 15 20 12 18 24 14 21 28 16 24 32
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec3 c  3 4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x3 expected  18 24 30 21 28 35 24 32 40 27 36 45
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec3 c  4 5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x3 expected  28 35 42 32 40 48 36 45 54 40 50 60
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec3 c  5 6 7
+uniform ivec4 r  8 9 10 11
+uniform mat4x3 expected  40 48 56 45 54 63 50 60 70 55 66 77
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x3.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x3.shader_test
new file mode 100644
index 00000000..57c3af98
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x3.shader_test
@@ -0,0 +1,59 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+# glUniformMatrix4x3fv only exists in OpenGL 2.1 or later.
+
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec3 c;
+uniform vec4 r;
+uniform mat4x3 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x3 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec3 c  2 3 4
+uniform vec4 r  5 6 7 8
+uniform mat4x3 expected  10 15 20 12 18 24 14 21 28 16 24 32
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec3 c  3 4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x3 expected  18 24 30 21 28 35 24 32 40 27 36 45
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec3 c  4 5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x3 expected  28 35 42 32 40 48 36 45 54 40 50 60
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec3 c  5 6 7
+uniform vec4 r  8 9 10 11
+uniform mat4x3 expected  40 48 56 45 54 63 50 60 70 55 66 77
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x4-ivec.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x4-ivec.shader_test
new file mode 100644
index 00000000..e0e450d8
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x4-ivec.shader_test
@@ -0,0 +1,77 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+/* From page 43 (page 49 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "If an exact match is found, the other signatures are ignored, and the
+ *     exact match is used. Otherwise, if no exact match is found, then the
+ *     implicit conversions in Section 4.1.10 "Implicit Conversions" will be
+ *     applied to the calling arguments if this can make their types match a
+ *     signature."
+ *
+ * From page 20 (page 26 of the PDF) of the GLSL 1.20 spec:
+ *
+ *     "In some situations, an expression and its type will be implicitly
+ *     converted to a different type. The following table shows all allowed
+ *     implicit conversions:
+ *
+ *         Type of expression    Can be implicitly converted to
+ *               int                         float
+ *              ivec2                         vec2
+ *              ivec3                         vec3
+ *              ivec4                         vec4"
+ */
+
+uniform ivec4 c;
+uniform ivec4 r;
+uniform mat4x4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform ivec4 c  2 3 4 5
+uniform ivec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform ivec4 c  3 4 5 6
+uniform ivec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform ivec4 c  4 5 6 7
+uniform ivec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform ivec4 c  5 6 7 8
+uniform ivec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x4.shader_test b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x4.shader_test
new file mode 100644
index 00000000..fe146fac
--- /dev/null
+++ b/tests/spec/glsl-es-1.00/execution/1.20/vs-outerProduct-mat4x4.shader_test
@@ -0,0 +1,57 @@
+[require]
+GLSL >= 1.00 es
+GL >= 2.0 es
+
+[vertex shader]
+attribute vec4 vertex;
+mat4 proj = mat4(
+	2.0/250.0, 0.0, 0.0, -1.0,
+	0.0, 2.0/250.0, 0.0, -1.0,
+	0.0, 0.0, -1.0, 0.0,
+	0.0, 0.0, 0.0, 1.0);
+
+uniform vec4 c;
+uniform vec4 r;
+uniform mat4x4 expected;
+varying vec4 color;
+
+void main() {
+  gl_Position = vertex;
+	gl_Position *= proj;
+  mat4x4 result = outerProduct(c, r);
+  color = (result == expected) ? vec4(0, 1, 0, 1) : vec4(1, 0, 0, 1);
+}
+
+[fragment shader]
+
+varying vec4 color;
+void main() { gl_FragColor = color; }
+
+[test]
+clear color 0.5 0.5 0.5 0.0
+clear
+
+
+uniform vec4 c  2 3 4 5
+uniform vec4 r  6 7 8 9
+uniform mat4x4 expected  12 18 24 30 14 21 28 35 16 24 32 40 18 27 36 45
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
+
+uniform vec4 c  3 4 5 6
+uniform vec4 r  7 8 9 10
+uniform mat4x4 expected  21 28 35 42 24 32 40 48 27 36 45 54 30 40 50 60
+draw rect 30 10 10 10
+probe rgb 35 15 0.0 1.0 0.0
+
+uniform vec4 c  4 5 6 7
+uniform vec4 r  8 9 10 11
+uniform mat4x4 expected  32 40 48 56 36 45 54 63 40 50 60 70 44 55 66 77
+draw rect 50 10 10 10
+probe rgb 55 15 0.0 1.0 0.0
+
+uniform vec4 c  5 6 7 8
+uniform vec4 r  9 10 11 12
+uniform mat4x4 expected  45 54 63 72 50 60 70 80 55 66 77 88 60 72 84 96
+draw rect 70 10 10 10
+probe rgb 75 15 0.0 1.0 0.0
diff --git a/tests/util/CMakeLists.gles2.txt b/tests/util/CMakeLists.gles2.txt
index 04701041..b81369c1 100644
--- a/tests/util/CMakeLists.gles2.txt
+++ b/tests/util/CMakeLists.gles2.txt
@@ -1,11 +1,11 @@
 set(UTIL_GL_SOURCES
 	${UTIL_GL_SOURCES}
+	minmax-test.c
 	piglit-vbo.cpp
 	piglit-shader.c
 	piglit-shader-gles2.c
 	piglit-util-gl-enum.c
 	piglit-util-gles.c
-	minmax-test.c
 	)
 
 include_directories(