Improve GLSL constant builtin tests.

Most of these are new, but I updated many old ones to test more values,
and values strictly between 0.0 and 1.0.  This ensures we don't
accidentally pass because a wrong result was clamped to that interval.

44 files changed, 688 insertions, 61 deletions

diff --git a/tests/all.tests b/tests/all.tests
index 312f9908..2a68a406 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -309,29 +309,53 @@ add_shader_generic(shaders, 'glsl-pp-elif-no-expression-1')
 add_shader_generic(shaders, 'glsl-implicit-conversion-01')
 add_shader_generic(shaders, 'glsl-const-builtin-abs')
 add_shader_generic(shaders, 'glsl-const-builtin-acos')
+add_shader_generic(shaders, 'glsl-const-builtin-all')
+add_shader_generic(shaders, 'glsl-const-builtin-any')
 add_shader_generic(shaders, 'glsl-const-builtin-asin')
 add_shader_generic(shaders, 'glsl-const-builtin-atan')
+add_shader_generic(shaders, 'glsl-const-builtin-ceil')
 add_shader_generic(shaders, 'glsl-const-builtin-clamp')
+add_shader_generic(shaders, 'glsl-const-builtin-cosh')
 add_shader_generic(shaders, 'glsl-const-builtin-cos')
+add_shader_generic(shaders, 'glsl-const-builtin-cross')
 add_shader_generic(shaders, 'glsl-const-builtin-degrees')
 add_shader_generic(shaders, 'glsl-const-builtin-derivatives')
+add_shader_generic(shaders, 'glsl-const-builtin-distance')
 add_shader_generic(shaders, 'glsl-const-builtin-dot')
+add_shader_generic(shaders, 'glsl-const-builtin-equal')
+add_shader_generic(shaders, 'glsl-const-builtin-exp')
 add_shader_generic(shaders, 'glsl-const-builtin-exp2')
-add_shader_generic(shaders, 'glsl-const-builtin-exp-log')
-add_shader_generic(shaders, 'glsl-const-builtin-floor-ceil')
+add_shader_generic(shaders, 'glsl-const-builtin-faceforward')
+add_shader_generic(shaders, 'glsl-const-builtin-floor')
 add_shader_generic(shaders, 'glsl-const-builtin-fract')
+add_shader_generic(shaders, 'glsl-const-builtin-greaterThanEqual')
 add_shader_generic(shaders, 'glsl-const-builtin-greaterThan')
 add_shader_generic(shaders, 'glsl-const-builtin-inversesqrt')
+add_shader_generic(shaders, 'glsl-const-builtin-length')
+add_shader_generic(shaders, 'glsl-const-builtin-lessThanEqual')
+add_shader_generic(shaders, 'glsl-const-builtin-lessThan')
+add_shader_generic(shaders, 'glsl-const-builtin-log')
 add_shader_generic(shaders, 'glsl-const-builtin-log2')
+add_shader_generic(shaders, 'glsl-const-builtin-matrixCompMult')
 add_shader_generic(shaders, 'glsl-const-builtin-max')
 add_shader_generic(shaders, 'glsl-const-builtin-min')
+add_shader_generic(shaders, 'glsl-const-builtin-mix')
 add_shader_generic(shaders, 'glsl-const-builtin-mod')
+add_shader_generic(shaders, 'glsl-const-builtin-normalize')
+add_shader_generic(shaders, 'glsl-const-builtin-not')
+add_shader_generic(shaders, 'glsl-const-builtin-notEqual')
+add_shader_generic(shaders, 'glsl-const-builtin-outerProduct')
 add_shader_generic(shaders, 'glsl-const-builtin-pow')
 add_shader_generic(shaders, 'glsl-const-builtin-radians')
+add_shader_generic(shaders, 'glsl-const-builtin-reflect')
+add_shader_generic(shaders, 'glsl-const-builtin-refract')
 add_shader_generic(shaders, 'glsl-const-builtin-sign')
 add_shader_generic(shaders, 'glsl-const-builtin-sin')
+add_shader_generic(shaders, 'glsl-const-builtin-smoothstep')
+add_shader_generic(shaders, 'glsl-const-builtin-step')
 add_shader_generic(shaders, 'glsl-const-builtin-sqrt')
 add_shader_generic(shaders, 'glsl-const-builtin-tan')
+add_shader_generic(shaders, 'glsl-const-builtin-transpose')
 add_plain_test(shaders, 'glsl-sin')
 add_plain_test(shaders, 'glsl-cos')
 add_plain_test(shaders, 'glsl-vs-if-bool')
diff --git a/tests/shaders/glsl-const-builtin-abs.shader_test b/tests/shaders/glsl-const-builtin-abs.shader_test
index 1c5af276..88fb2bbd 100644
--- a/tests/shaders/glsl-const-builtin-abs.shader_test
+++ b/tests/shaders/glsl-const-builtin-abs.shader_test
@@ -10,7 +10,9 @@ glsl-mvp.vert
 void main()
 {
     const float x = abs(-0.5);
-    gl_FragColor = vec4(0.0, x + x, 0.0, 1.0);
+    const float y = abs(0.0);
+    const float z = abs(0.5);
+    gl_FragColor = vec4(x, y, z, 1.0);
 }
 
 [test]
@@ -18,4 +20,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.5 0.0 0.5
diff --git a/tests/shaders/glsl-const-builtin-acos.shader_test b/tests/shaders/glsl-const-builtin-acos.shader_test
index 0ceb1cb7..0e29fa14 100644
--- a/tests/shaders/glsl-const-builtin-acos.shader_test
+++ b/tests/shaders/glsl-const-builtin-acos.shader_test
@@ -9,8 +9,9 @@ glsl-mvp.vert
 #version 120
 void main() {
    const float zero = acos(1.0);
-   const float zero2 = acos(1.0);
-   gl_FragColor = vec4(zero, 1.0, zero2, 1.0);
+   const float half_pi = acos(0.0);
+   const float pi = acos(-1.0);
+   gl_FragColor = vec4(zero, half_pi - 1.0, pi - 3.0, 1.0);
 }
 
 [test]
@@ -18,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.0 0.5707963267949 0.14159265358979
diff --git a/tests/shaders/glsl-const-builtin-all.shader_test b/tests/shaders/glsl-const-builtin-all.shader_test
new file mode 100644
index 00000000..79a61aa3
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-all.shader_test
@@ -0,0 +1,26 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const bvec2 v_true = bvec2(true, true);
+    const bvec2 v_some = bvec2(true, false);
+    const bvec2 v_none = bvec2(false, false);
+    const bool true1 = all(v_true);
+    const bool false1 = all(v_some);
+    const bool false2 = all(v_none);
+    gl_FragColor = vec4(float(false1), float(true1), float(false2), 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/shaders/glsl-const-builtin-any.shader_test b/tests/shaders/glsl-const-builtin-any.shader_test
new file mode 100644
index 00000000..cb372266
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-any.shader_test
@@ -0,0 +1,26 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const bvec2 v_true = bvec2(true, true);
+    const bvec2 v_some = bvec2(true, false);
+    const bvec2 v_none = bvec2(false, false);
+    const bool true1 = any(v_true);
+    const bool true2 = any(v_some);
+    const bool false1 = any(v_none);
+    gl_FragColor = vec4(float(true1), float(true2), float(false1), 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 1.0 1.0 0.0
diff --git a/tests/shaders/glsl-const-builtin-asin.shader_test b/tests/shaders/glsl-const-builtin-asin.shader_test
index db5a535e..dd1ee4c0 100644
--- a/tests/shaders/glsl-const-builtin-asin.shader_test
+++ b/tests/shaders/glsl-const-builtin-asin.shader_test
@@ -9,7 +9,9 @@ glsl-mvp.vert
 #version 120
 void main() {
    const float zero = asin(0.0);
-   gl_FragColor = vec4(zero, 1.0, zero, 1.0);
+   const float pi_over_three = asin(0.866025403784439);
+   const float half_pi = asin(1.0);
+   gl_FragColor = vec4(zero, pi_over_three - 1.0, half_pi - 1.0, 1.0);
 }
 
 [test]
@@ -17,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.0 0.0471975511966 0.5707963267949
diff --git a/tests/shaders/glsl-const-builtin-ceil.shader_test b/tests/shaders/glsl-const-builtin-ceil.shader_test
new file mode 100644
index 00000000..9bfb3b53
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-ceil.shader_test
@@ -0,0 +1,23 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const float x = ceil(-0.5);
+    const float y = ceil(0.0);
+    const float z = ceil(0.5);
+    gl_FragColor = vec4(x, y, z, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 0.0 1.0
diff --git a/tests/shaders/glsl-const-builtin-cos.shader_test b/tests/shaders/glsl-const-builtin-cos.shader_test
index 8a53d00a..fe68baae 100644
--- a/tests/shaders/glsl-const-builtin-cos.shader_test
+++ b/tests/shaders/glsl-const-builtin-cos.shader_test
@@ -8,8 +8,10 @@ glsl-mvp.vert
 [fragment shader]
 #version 120
 void main() {
+   const float sqrt_two_over_two = cos(0.785398163397448);
    const float one = cos(0.0);
-   gl_FragColor = vec4(0, one, 0, one);
+   const float one_half = cos(-1.0471975511966);
+   gl_FragColor = vec4(sqrt_two_over_two, one, one_half, 1.0);
 }
 
 [test]
@@ -17,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.707106781186548 1.0 0.5
diff --git a/tests/shaders/glsl-const-builtin-cosh.shader_test b/tests/shaders/glsl-const-builtin-cosh.shader_test
new file mode 100644
index 00000000..6f6d3776
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-cosh.shader_test
@@ -0,0 +1,22 @@
+[require]
+GL >= 2.0
+GLSL >= 1.30
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 130
+void main() {
+   const float f_154 = cosh(1.0);
+   const float f_376 = cosh(2.0);
+   const float f_1006 = cosh(-3.0);
+   gl_FragColor = vec4(f_154 - 1.0, f_376 - 3.0, f_1006 - 10.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.54308063481524 0.76219569108363 0.0676619957778 1.0
diff --git a/tests/shaders/glsl-const-builtin-cross.shader_test b/tests/shaders/glsl-const-builtin-cross.shader_test
new file mode 100644
index 00000000..70b99754
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-cross.shader_test
@@ -0,0 +1,26 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec3 v1 = vec3(3.0, -3.0, 1.0);
+    const vec3 v2 = vec3(4.0,  9.0, 2.0);
+    const vec3 cp = cross(v1, v2);
+    if (cp == vec3(-15.0, -2.0, 39.0))
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+    else
+        gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0 1 0
diff --git a/tests/shaders/glsl-const-builtin-distance.shader_test b/tests/shaders/glsl-const-builtin-distance.shader_test
new file mode 100644
index 00000000..6cb5ba9e
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-distance.shader_test
@@ -0,0 +1,24 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec2 p0 = vec2(1.2, 3.4);
+    const vec2 p1 = vec2(4.9, -5.6);
+    const float dist1 = distance(p0, p1);
+    const float dist2 = distance(p1, p0);
+    gl_FragColor = vec4(dist1 - 9.0, dist2 - 9.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.73087868591526 0.73087868591526
diff --git a/tests/shaders/glsl-const-builtin-dot.shader_test b/tests/shaders/glsl-const-builtin-dot.shader_test
index c18e0984..4672bbfc 100644
--- a/tests/shaders/glsl-const-builtin-dot.shader_test
+++ b/tests/shaders/glsl-const-builtin-dot.shader_test
@@ -9,10 +9,13 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-   const vec2 c1 = vec2(0.5, 0.25);
-   const vec2 c2 = vec2(1.0, 2.0);
+   const vec2 c1 = vec2(2.0, 4.0);
+   const vec2 c2 = vec2(1.0, 5.0);
    const float c = dot(c1, c2);
-   gl_FragColor = vec4(0.0, c, 0.0, 0.0);
+   if (c == 22.0)
+      gl_FragColor = vec4(0.0, 1.0, 0.0, 0.0);
+   else
+      gl_FragColor = vec4(1.0, 0.0, 0.0, 0.0);
 }
 
 [test]
diff --git a/tests/shaders/glsl-const-builtin-equal.shader_test b/tests/shaders/glsl-const-builtin-equal.shader_test
new file mode 100644
index 00000000..d6e0e6a0
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-equal.shader_test
@@ -0,0 +1,22 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main() {
+   const vec3 small = vec3(1.0, 2.0, 3.0);
+   const vec3 large = vec3(0.5, 2.0, 6.0);
+   const bvec3 result = equal(large, small);
+   gl_FragColor = vec4(result, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.0
diff --git a/tests/shaders/glsl-const-builtin-exp.shader_test b/tests/shaders/glsl-const-builtin-exp.shader_test
new file mode 100644
index 00000000..92d3795f
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-exp.shader_test
@@ -0,0 +1,21 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec3 v = exp(vec3(0.0, -2.0, 4.0));
+    gl_FragColor = vec4(v.x, v.y, v.z - 54.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 1.0 0.1353352832366127 0.598150033144236
diff --git a/tests/shaders/glsl-const-builtin-exp2.shader_test b/tests/shaders/glsl-const-builtin-exp2.shader_test
index 68b59cdd..4709181b 100644
--- a/tests/shaders/glsl-const-builtin-exp2.shader_test
+++ b/tests/shaders/glsl-const-builtin-exp2.shader_test
@@ -9,8 +9,8 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-    const float one = exp2(16.0) - 65535;
-    gl_FragColor = vec4(0.0, one, 0.0, one);
+    const float one_half = exp2(16.0) - 65535.5;
+    gl_FragColor = vec4(0.0, one_half, 0.0, 1.0);
 }
 
 [test]
@@ -18,4 +18,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.0 0.5 0.0
diff --git a/tests/shaders/glsl-const-builtin-faceforward.shader_test b/tests/shaders/glsl-const-builtin-faceforward.shader_test
new file mode 100644
index 00000000..4565dfc0
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-faceforward.shader_test
@@ -0,0 +1,29 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec2 v1 = vec2(1.0, 2.0);
+    const vec2 v2 = vec2(4.0, -5.0);
+
+    const vec2 v3 = faceforward(v1, v1, v2);
+    const vec2 v4 = faceforward(v1, v1, v1);
+
+    if (v3 == v1 && v4 == -v1)
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+    else
+        gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0 1 0
diff --git a/tests/shaders/glsl-const-builtin-floor.shader_test b/tests/shaders/glsl-const-builtin-floor.shader_test
new file mode 100644
index 00000000..ff0ba01d
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-floor.shader_test
@@ -0,0 +1,23 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const float x = floor(-0.5);
+    const float y = floor(0.0);
+    const float z = floor(0.5);
+    gl_FragColor = vec4(x + 1.7, y, z, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.7 0.0 0.0
diff --git a/tests/shaders/glsl-const-builtin-fract.shader_test b/tests/shaders/glsl-const-builtin-fract.shader_test
index ac6d9ba4..9685fc8d 100644
--- a/tests/shaders/glsl-const-builtin-fract.shader_test
+++ b/tests/shaders/glsl-const-builtin-fract.shader_test
@@ -9,8 +9,10 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-   const float one = fract(5.1) * 10.0;
-   gl_FragColor = vec4(0.0, one, 0.0, one);
+   const float x = fract(1.7);
+   const float y = fract(6.0);
+   const float z = fract(-1.7); /* should be 0.3 */
+   gl_FragColor = vec4(x, y, z, 1.0);
 }
 
 [test]
@@ -18,4 +20,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.7 0.0 0.3
diff --git a/tests/shaders/glsl-const-builtin-greaterThan.shader_test b/tests/shaders/glsl-const-builtin-greaterThan.shader_test
index cecf7baa..9e42f976 100644
--- a/tests/shaders/glsl-const-builtin-greaterThan.shader_test
+++ b/tests/shaders/glsl-const-builtin-greaterThan.shader_test
@@ -8,13 +8,10 @@ glsl-mvp.vert
 [fragment shader]
 #version 120
 void main() {
-   const vec2 small = vec2(1.0, 2.0);
-   const vec2 large = vec2(2.0, 3.0);
-   const bvec2 gt = greaterThan(large, small);
-   if (gt.x && gt.y)
-      gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
-   else
-      gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
+   const vec3 small = vec3(1.0, 2.0, 3.0);
+   const vec3 large = vec3(0.5, 2.0, 6.0);
+   const bvec3 result = greaterThan(large, small);
+   gl_FragColor = vec4(result, 1.0);
 }
 
 [test]
@@ -22,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.0 0.0 1.0
diff --git a/tests/shaders/glsl-const-builtin-greaterThanEqual.shader_test b/tests/shaders/glsl-const-builtin-greaterThanEqual.shader_test
new file mode 100644
index 00000000..5a5c2408
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-greaterThanEqual.shader_test
@@ -0,0 +1,22 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main() {
+   const vec3 small = vec3(1.0, 2.0, 3.0);
+   const vec3 large = vec3(0.5, 2.0, 6.0);
+   const bvec3 result = greaterThanEqual(large, small);
+   gl_FragColor = vec4(result, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 1.0
diff --git a/tests/shaders/glsl-const-builtin-inversesqrt.shader_test b/tests/shaders/glsl-const-builtin-inversesqrt.shader_test
index f8b72382..fc35e806 100644
--- a/tests/shaders/glsl-const-builtin-inversesqrt.shader_test
+++ b/tests/shaders/glsl-const-builtin-inversesqrt.shader_test
@@ -9,9 +9,13 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-    const vec4 q = inversesqrt(vec4(16.0));
-    const float one = q.x + q.y + q.z + q.w;
-    gl_FragColor = vec4(0.0, one, 0.0, one);
+    const vec3 v = inversesqrt(vec3(16.0));
+
+    /* The following values are undefined but the compiler should not crash. */
+    const float undef1 = inversesqrt(0.0);
+    const float undef2 = inversesqrt(-1.0);
+
+    gl_FragColor = vec4(v, undef1 + undef2);
 }
 
 [test]
@@ -19,4 +23,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.25 0.25 0.25
diff --git a/tests/shaders/glsl-const-builtin-floor-ceil.shader_test b/tests/shaders/glsl-const-builtin-length.shader_test
index 668b8e82..06731edb 100644
--- a/tests/shaders/glsl-const-builtin-floor-ceil.shader_test
+++ b/tests/shaders/glsl-const-builtin-length.shader_test
@@ -9,8 +9,9 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-   const float one = ceil(1.4) - floor(1.4);
-   gl_FragColor = vec4(0.0, one, 0.0, one);
+    const vec2 v = vec2(12.0, -5.0);
+    const float length = length(v);
+    gl_FragColor = vec4(0.0, length - 12.5, 0.0, 1.0);
 }
 
 [test]
@@ -18,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0 0.5 0
diff --git a/tests/shaders/glsl-const-builtin-lessThan.shader_test b/tests/shaders/glsl-const-builtin-lessThan.shader_test
new file mode 100644
index 00000000..4baf2b83
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-lessThan.shader_test
@@ -0,0 +1,22 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main() {
+   const vec3 small = vec3(1.0, 2.0, 3.0);
+   const vec3 large = vec3(0.5, 2.0, 6.0);
+   const bvec3 result = lessThan(large, small);
+   gl_FragColor = vec4(result, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 1.0 0.0 0.0
diff --git a/tests/shaders/glsl-const-builtin-lessThanEqual.shader_test b/tests/shaders/glsl-const-builtin-lessThanEqual.shader_test
new file mode 100644
index 00000000..66a82b62
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-lessThanEqual.shader_test
@@ -0,0 +1,22 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main() {
+   const vec3 small = vec3(1.0, 2.0, 3.0);
+   const vec3 large = vec3(0.5, 2.0, 6.0);
+   const bvec3 result = lessThanEqual(large, small);
+   gl_FragColor = vec4(result, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 1.0 1.0 0.0
diff --git a/tests/shaders/glsl-const-builtin-log.shader_test b/tests/shaders/glsl-const-builtin-log.shader_test
new file mode 100644
index 00000000..8ae45f02
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-log.shader_test
@@ -0,0 +1,24 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec3 v = log(vec3(1.0, 0.1353352832366127, 54.598150033144236));
+    if (v == vec3(0.0, -2.0, 4.0))
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+    else
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0 1 0
diff --git a/tests/shaders/glsl-const-builtin-log2.shader_test b/tests/shaders/glsl-const-builtin-log2.shader_test
index c46c3a55..8d8048ea 100644
--- a/tests/shaders/glsl-const-builtin-log2.shader_test
+++ b/tests/shaders/glsl-const-builtin-log2.shader_test
@@ -9,8 +9,11 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-    const float one = log2(65536.0) - 15;
-    gl_FragColor = vec4(0.0, one, 0.0, one);
+    const vec3 v = log2(vec3(1.0, 8.0, 65536.0));
+    if (v == vec3(0.0, 3.0, 16.0))
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+    else
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
 }
 
 [test]
@@ -18,4 +21,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0 1 0
diff --git a/tests/shaders/glsl-const-builtin-matrixCompMult.shader_test b/tests/shaders/glsl-const-builtin-matrixCompMult.shader_test
new file mode 100644
index 00000000..2029770f
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-matrixCompMult.shader_test
@@ -0,0 +1,26 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const mat2 m1 = mat2(1.0, 2.0, 4.0,  8.0);
+    const mat2 m2 = mat2(1.0, 0.5, 0.25, 0.125);
+    const mat2 m3 = matrixCompMult(m1, m2);
+    if (m3 == mat2(1.0, 1.0, 1.0, 1.0))
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+    else
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0 1 0
diff --git a/tests/shaders/glsl-const-builtin-max.shader_test b/tests/shaders/glsl-const-builtin-max.shader_test
index af0a2dc0..62d32fc6 100644
--- a/tests/shaders/glsl-const-builtin-max.shader_test
+++ b/tests/shaders/glsl-const-builtin-max.shader_test
@@ -11,7 +11,7 @@ void main()
 {
     const float x = max(0.25, -5.0);
     const vec2 v = max(vec2(0.5, 0.2), 0.25);
-    gl_FragColor = vec4(0.0, x + v.x + v.y, 0.0, 1.0);
+    gl_FragColor = vec4(x, v, 1.0);
 }
 
 [test]
@@ -19,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.25 0.5 0.25
diff --git a/tests/shaders/glsl-const-builtin-min.shader_test b/tests/shaders/glsl-const-builtin-min.shader_test
index 754934cb..6d2fc1c0 100644
--- a/tests/shaders/glsl-const-builtin-min.shader_test
+++ b/tests/shaders/glsl-const-builtin-min.shader_test
@@ -11,7 +11,7 @@ void main()
 {
     const float x = min(0.25, 0.5);
     const vec2 v = min(vec2(0.25, 0.7), 0.5);
-    gl_FragColor = vec4(0.0, x + v.x + v.y, 0.0, 1.0);
+    gl_FragColor = vec4(x, v, 1.0);
 }
 
 [test]
@@ -19,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.25 0.25 0.5
diff --git a/tests/shaders/glsl-const-builtin-mix.shader_test b/tests/shaders/glsl-const-builtin-mix.shader_test
new file mode 100644
index 00000000..70466f83
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-mix.shader_test
@@ -0,0 +1,24 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec4 v1 = vec4(1.0, 0.0, 2.0, 0.0);
+    const vec4 v2 = vec4(0.0, 1.0, 0.0, 2.0);
+    const vec4 v3 = vec4(0.5, 0.5, 0.75, 0.25);
+    const vec4 vm = mix(v1, v2, v3);
+    gl_FragColor = vm;
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.5 0.5 0.5
diff --git a/tests/shaders/glsl-const-builtin-mod.shader_test b/tests/shaders/glsl-const-builtin-mod.shader_test
index c5e31691..d49a034a 100644
--- a/tests/shaders/glsl-const-builtin-mod.shader_test
+++ b/tests/shaders/glsl-const-builtin-mod.shader_test
@@ -9,9 +9,9 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-   const vec2 v1 = mod(vec2(5.0, 4.0), 3.0);
-   const vec2 v2 = mod(vec2(5.0, 6.0), vec2(3.0, 5.0));
-   gl_FragColor = vec4(0.0, v1.x - v1.y, 0.0, v2.x - v2.y);
+   const vec2 v1 = mod(vec2(-3.0, 43.5), vec2(0.9, -4.0)); /* (-0.5, 0.6) */
+   const vec2 v2 = mod(vec2(0.2, 6.0), 1.3);
+   gl_FragColor = vec4(v1.x + v1.y, v2, 1.0);
 }
 
 [test]
@@ -19,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgba 15 15 0.0 1.0 0.0 1.0
+probe rgb 15 15 0.1 0.2 0.8
diff --git a/tests/shaders/glsl-const-builtin-normalize.shader_test b/tests/shaders/glsl-const-builtin-normalize.shader_test
new file mode 100644
index 00000000..6c1d1dff
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-normalize.shader_test
@@ -0,0 +1,27 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec2 v = normalize(vec2(1.0, 1.0));
+
+    /* Attempt to normalize the zero vector.  The specification is unclear
+     * about the results, but ATI returns the zero vector.  At any rate, the
+     * compiler should not crash.
+     */
+    const vec2 z = normalize(vec2(0.0, 0.0));
+    gl_FragColor = vec4(v.x, z.x, z.y, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.7071067811865475 0.0 0.0
diff --git a/tests/shaders/glsl-const-builtin-exp-log.shader_test b/tests/shaders/glsl-const-builtin-not.shader_test
index 5718ceca..14a50f29 100644
--- a/tests/shaders/glsl-const-builtin-exp-log.shader_test
+++ b/tests/shaders/glsl-const-builtin-not.shader_test
@@ -9,8 +9,8 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-    const float one = log(exp(2.0)) - 1.0;
-    gl_FragColor = vec4(0.0, one, 0.0, one);
+    const bvec4 v = not(bvec4(true, false, true, false));
+    gl_FragColor = vec4(v);
 }
 
 [test]
@@ -18,4 +18,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgba 15 15 0.0 1.0 0.0 1.0
diff --git a/tests/shaders/glsl-const-builtin-notEqual.shader_test b/tests/shaders/glsl-const-builtin-notEqual.shader_test
new file mode 100644
index 00000000..44538f49
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-notEqual.shader_test
@@ -0,0 +1,22 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main() {
+   const vec3 small = vec3(1.0, 2.0, 3.0);
+   const vec3 large = vec3(0.5, 2.0, 6.0);
+   const bvec3 result = notEqual(large, small);
+   gl_FragColor = vec4(result, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 1.0 0.0 1.0
diff --git a/tests/shaders/glsl-const-builtin-outerProduct.shader_test b/tests/shaders/glsl-const-builtin-outerProduct.shader_test
new file mode 100644
index 00000000..7163d99b
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-outerProduct.shader_test
@@ -0,0 +1,32 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec3 u = vec3(2.0, 3.0, 4.0);
+    const vec2 v = vec2(5.0, 6.0);
+    /* should be:
+     * 10 12
+     * 15 18
+     * 20 24
+     */
+    const mat2x3 m = outerProduct(u, v);
+
+    if (m[0] == vec3(10.0, 15.0, 20.0) && m[1] == vec3(12.0, 18.0, 24.0))
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+    else
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0 1 0
diff --git a/tests/shaders/glsl-const-builtin-pow.shader_test b/tests/shaders/glsl-const-builtin-pow.shader_test
index da5ec66c..83c9dbba 100644
--- a/tests/shaders/glsl-const-builtin-pow.shader_test
+++ b/tests/shaders/glsl-const-builtin-pow.shader_test
@@ -9,9 +9,9 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-    const vec2 v = pow(vec2(2,9), vec2(2,0.5));
-    const float one = v.x - v.y;
-    gl_FragColor = vec4(0.0, one, 0.0, one);
+    const vec2 v = pow(vec2(3,65), vec2(2,0.5));
+    const float splat = v.x - v.y;
+    gl_FragColor = vec4(0.0, splat, 0.0, 1.0);
 }
 
 [test]
@@ -19,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.0 0.937742251701451 0.0
diff --git a/tests/shaders/glsl-const-builtin-reflect.shader_test b/tests/shaders/glsl-const-builtin-reflect.shader_test
new file mode 100644
index 00000000..b1ddc843
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-reflect.shader_test
@@ -0,0 +1,23 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec3 v1 = vec3(-1.0, 0.0, 0.0);
+    const vec3 v2 = vec3(0.70710678, 0.70710678, 0.0);
+    const vec3 r = reflect(v1, v2);
+    gl_FragColor = vec4(r, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgba 15 15 0 1 0 1
diff --git a/tests/shaders/glsl-const-builtin-refract.shader_test b/tests/shaders/glsl-const-builtin-refract.shader_test
new file mode 100644
index 00000000..7cbd4747
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-refract.shader_test
@@ -0,0 +1,24 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const float zero = refract(0.0, 0.0, 2.0);
+    const vec2 v1 = vec2(-1.0, 0.0);
+    const vec2 v2 = vec2(0.70710678, 0.70710678);
+    const vec2 r = refract(v1, v2, 0.5);
+    gl_FragColor = vec4(r.x + 1.0, r.y + 1.0, zero, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.0885621726633092 0.588562172663309 0
diff --git a/tests/shaders/glsl-const-builtin-sin.shader_test b/tests/shaders/glsl-const-builtin-sin.shader_test
index 68475528..26482adb 100644
--- a/tests/shaders/glsl-const-builtin-sin.shader_test
+++ b/tests/shaders/glsl-const-builtin-sin.shader_test
@@ -8,8 +8,10 @@ glsl-mvp.vert
 [fragment shader]
 #version 120
 void main() {
+   const float sqrt_two_over_two = sin(0.785398163397448);
    const float one = sin(1.5707963267949);
-   gl_FragColor = vec4(0, one, 0, one);
+   const float one_half = sin(2.61799387799149);
+   gl_FragColor = vec4(sqrt_two_over_two, one, one_half, 1.0);
 }
 
 [test]
@@ -17,4 +19,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.707106781186548 1.0 0.5
diff --git a/tests/shaders/glsl-const-builtin-smoothstep.shader_test b/tests/shaders/glsl-const-builtin-smoothstep.shader_test
new file mode 100644
index 00000000..79e76435
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-smoothstep.shader_test
@@ -0,0 +1,22 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec3 v = vec3(7.0, 22.0, 20.0);
+    const vec3 r = smoothstep(14.0, 22.0, v);
+    gl_FragColor = vec4(r, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0.0 1.0 0.84375
diff --git a/tests/shaders/glsl-const-builtin-sqrt.shader_test b/tests/shaders/glsl-const-builtin-sqrt.shader_test
index bd555520..69d1ea73 100644
--- a/tests/shaders/glsl-const-builtin-sqrt.shader_test
+++ b/tests/shaders/glsl-const-builtin-sqrt.shader_test
@@ -9,8 +9,8 @@ glsl-mvp.vert
 #version 120
 void main()
 {
-    const float one = sqrt(16.0) - 3;
-    gl_FragColor = vec4(0.0, one, 0.0, one);
+    const float one_half = sqrt(16.0) - 3.5;
+    gl_FragColor = vec4(0.0, one_half, 0.0, 1.0);
 }
 
 [test]
@@ -18,4 +18,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.0 0.5 0.0
diff --git a/tests/shaders/glsl-const-builtin-step.shader_test b/tests/shaders/glsl-const-builtin-step.shader_test
new file mode 100644
index 00000000..42d087ca
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-step.shader_test
@@ -0,0 +1,23 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const vec4 v1 = vec4(1.0, 1.0, 0.0, -1.0);
+    const vec4 v2 = vec4(1.0, 0.0, 1.0, 0.0);
+    const vec4 r = step(v1, v2);
+    gl_FragColor = r;
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 1.0 0.0 1.0
diff --git a/tests/shaders/glsl-const-builtin-tan.shader_test b/tests/shaders/glsl-const-builtin-tan.shader_test
index af7f4bdf..b2064a17 100644
--- a/tests/shaders/glsl-const-builtin-tan.shader_test
+++ b/tests/shaders/glsl-const-builtin-tan.shader_test
@@ -8,8 +8,11 @@ glsl-mvp.vert
 [fragment shader]
 #version 120
 void main() {
-   const float one = tan(0.785398163397448);
-   gl_FragColor = vec4(0, one, 0, one);
+    const float one = tan(0.785398163397448);
+    const float sqrt3 = tan(1.0471975511965976);
+    const float zero = tan(0.0);
+
+    gl_FragColor = vec4(zero, one, sqrt3 - 1.0, 1.0);
 }
 
 [test]
@@ -17,4 +20,4 @@ clear color 0.0 0.0 0.0 0.0
 clear
 ortho
 draw rect 10 10 10 10
-probe rgb 15 15 0.0 1.0 0.0
+probe rgb 15 15 0.0 1.0 0.7320508075688772
diff --git a/tests/shaders/glsl-const-builtin-transpose.shader_test b/tests/shaders/glsl-const-builtin-transpose.shader_test
new file mode 100644
index 00000000..a07708c6
--- /dev/null
+++ b/tests/shaders/glsl-const-builtin-transpose.shader_test
@@ -0,0 +1,26 @@
+[require]
+GL >= 2.0
+GLSL >= 1.20
+
+[vertex shader file]
+glsl-mvp.vert
+
+[fragment shader]
+#version 120
+void main()
+{
+    const mat2 m = mat2(1.0, 2.0, 4.0,  8.0);
+    const mat2 mt = transpose(m);
+    const mat2 mtt = transpose(mt);
+    if (m == mat2(1.0, 4.0, 2.0, 8.0) && mt == mtt)
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+    else
+        gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+clear color 0.0 0.0 0.0 0.0
+clear
+ortho
+draw rect 10 10 10 10
+probe rgb 15 15 0 1 0