[7/8] arb_gpu_shader_fp64: add tests for UBOs

Submitted by Andres Gomez on March 15, 2016, 3:50 p.m.

Details

Message ID 1458057049-9466-8-git-send-email-agomez@igalia.com
State Accepted
Headers show
Series "Additional tests for ARB_gpu_shader_fp64 extension" ( rev: 2 1 ) in Piglit

Not browsing as part of any series.

Commit Message

Andres Gomez March 15, 2016, 3:50 p.m.
From: "Juan A. Suarez Romero" <jasuarez@igalia.com>

Add several tests for double-precision usage inside UBOs.

Signed-off-by: Andres Gomez <agomez@igalia.com>
---
 .../uniform_buffers/fs-array-copy.shader_test      | 40 +++++++++++
 .../uniform_buffers/fs-dmat4-row-major.shader_test | 33 +++++++++
 .../uniform_buffers/fs-dmat4.shader_test           | 34 +++++++++
 .../fs-double-array-const-index.shader_test        | 37 ++++++++++
 .../fs-double-array-variable-index.shader_test     | 45 ++++++++++++
 .../fs-double-bool-double.shader_test              | 38 ++++++++++
 ...ouble-uniform-array-direct-indirect.shader_test | 34 +++++++++
 .../fs-doubles-float-mixed.shader_test             | 40 +++++++++++
 .../uniform_buffers/fs-doubles.shader_test         | 40 +++++++++++
 ...dvec4-uniform-array-direct-indirect.shader_test | 32 +++++++++
 .../uniform_buffers/fs-nested-struct.shader_test   | 56 +++++++++++++++
 .../uniform_buffers/fs-ubo-direct-1.shader_test    | 38 ++++++++++
 .../fs-ubo-load.indirect.1.shader_test             | 38 ++++++++++
 .../fs-ubo-load.indirect.2.shader_test             | 34 +++++++++
 .../fs-ubo-load.indirect.3.shader_test             | 37 ++++++++++
 .../fs-ubo-load.indirect.4.shader_test             | 52 ++++++++++++++
 .../uniform_buffers/gs-array-copy.shader_test      | 69 ++++++++++++++++++
 .../uniform_buffers/gs-dmat4-row-major.shader_test | 60 ++++++++++++++++
 .../uniform_buffers/gs-dmat4.shader_test           | 60 ++++++++++++++++
 .../gs-double-array-const-index.shader_test        | 63 ++++++++++++++++
 .../gs-double-array-variable-index.shader_test     | 71 ++++++++++++++++++
 .../gs-double-bool-double.shader_test              | 65 +++++++++++++++++
 ...ouble-uniform-array-direct-indirect.shader_test | 64 +++++++++++++++++
 .../gs-doubles-float-mixed.shader_test             | 66 +++++++++++++++++
 ...dvec4-uniform-array-direct-indirect.shader_test | 62 ++++++++++++++++
 .../uniform_buffers/gs-nested-struct.shader_test   | 83 ++++++++++++++++++++++
 26 files changed, 1291 insertions(+)
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test
 create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test

Patch hide | download patch | download mbox

diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test
new file mode 100644
index 0000000..5e68932
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test
@@ -0,0 +1,40 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int i;
+uniform ubo1 {
+	dvec4 colors[4];
+};
+
+out vec4 color;
+
+void main()
+{
+	dvec4 temp[4] = colors;
+	temp[0] = dvec4(1.0, 0.0, arg0, 0.0);
+        dvec4 result = temp[i];
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.0 1.0 0.0 0.0
+uniform int i 1
+uniform dvec4 colors[0] 0.0 0.0 0.0 0.0
+uniform dvec4 colors[1] 0.0 1.0 0.0 0.0
+uniform dvec4 colors[2] 0.0 1.0 1.0 0.0
+uniform dvec4 colors[3] 1.0 0.0 1.0 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test
new file mode 100644
index 0000000..7f40e77
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test
@@ -0,0 +1,33 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+	layout(row_major) dmat4 m;
+};
+
+out vec4 color;
+
+void main()
+{
+        dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+uniform dmat4 m 0.25 0.0 0.0 0.0   0.0 0.0 0.75 0.0   0.0 0.5 0.0 0.0   0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
\ No newline at end of file
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test
new file mode 100644
index 0000000..e4f01c9
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test
@@ -0,0 +1,34 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+	dmat4 m;
+};
+
+out vec4 color;
+
+void main()
+{
+	dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+
+uniform dmat4 m 0.25 0.0 0.0 0.0   0.0 0.0 0.75 0.0   0.0 0.5 0.0 0.0   0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test
new file mode 100644
index 0000000..16f2ea2
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test
@@ -0,0 +1,37 @@ 
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+  double d[4];
+};
+
+out vec4 color;
+
+void main()
+{
+  dvec4 result = dvec4(d[0] + arg0, d[1], d[2], d[3]);
+  color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test
new file mode 100644
index 0000000..d2cff9f
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test
@@ -0,0 +1,45 @@ 
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int ri, gi, bi, ai;
+
+uniform ubo1 {
+  double d[4];
+};
+
+out vec4 color;
+
+void main()
+{
+  dvec4 result = dvec4(d[ri] + arg0, d[gi], d[bi], d[ai]);
+  color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+
+uniform int ri 0
+uniform int gi 1
+uniform int bi 2
+uniform int ai 3
+
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test
new file mode 100644
index 0000000..3698458
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test
@@ -0,0 +1,38 @@ 
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg0;
+uniform bool arg1;
+uniform double arg2;
+
+out vec4 color;
+
+void main()
+{
+  dvec4 result;
+  if (arg1)
+    result = dvec4(arg0, arg2, 0.0, 0.0);
+  else
+    result = dvec4(arg0, arg2, 1.0, 0.0);
+  color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 1.0 1.0 0.0 0.0
+uniform double arg0 1.0
+uniform int arg1 1
+uniform double arg2 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..1de93e9
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,34 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg[7];
+out vec4 color;
+void main()
+{
+        dvec4 result = dvec4(arg[int(arg[6])] + arg0);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.65 0.65 0.65 0.65
+uniform double arg[0] 0.1
+uniform double arg[1] 0.2
+uniform double arg[2] 0.3
+uniform double arg[3] 0.4
+uniform double arg[4] 0.5
+uniform double arg[5] 0.6
+uniform double arg[6] 3.0
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test
new file mode 100644
index 0000000..a150fef
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test
@@ -0,0 +1,40 @@ 
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+  double r;
+  float g;
+  double b;
+  double a;
+};
+
+out vec4 color;
+
+void main()
+{
+  dvec4 result = dvec4(r + arg0, g, b, a);
+  color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 1.0 0.0
+uniform double r 0.0
+uniform float g 1.0
+uniform double b 1.0
+uniform double a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test
new file mode 100644
index 0000000..9e57608
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test
@@ -0,0 +1,40 @@ 
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+  double r;
+  double g;
+  double b;
+  double a;
+};
+
+out vec4 color;
+
+void main()
+{
+  dvec4 result = dvec4(r + arg0, g, b, a);
+  color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double r 0.0
+uniform double g 1.0
+uniform double b 0.0
+uniform double a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..239ec59
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,32 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform dvec4 arg[7];
+out vec4 color;
+void main()
+{
+        dvec4 result = dvec4(arg[int(arg[6].w)]);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 0.40 0.41 0.42 0.43
+uniform dvec4 arg[0] 0.10 0.11 0.12 0.13
+uniform dvec4 arg[1] 0.20 0.21 0.22 0.23
+uniform dvec4 arg[2] 0.30 0.31 0.32 0.33
+uniform dvec4 arg[3] 0.40 0.41 0.42 0.43
+uniform dvec4 arg[4] 0.50 0.51 0.52 0.53
+uniform dvec4 arg[5] 0.60 0.61 0.62 0.63
+uniform dvec4 arg[6] 0.70 0.71 0.72 3.00
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test
new file mode 100644
index 0000000..e026795
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test
@@ -0,0 +1,56 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+struct S1 {
+	double r;
+};
+
+struct S2 {
+	float p1;
+	double r;
+        double g;
+        double b;
+        float p2;
+	double a;
+};
+
+struct S {
+       S1 s1;
+       S2 s2;
+};
+
+uniform ubo1 {
+	S s;
+};
+
+out vec4 color;
+
+void main()
+{
+        dvec4 result = dvec4(s.s1.r + arg0, s.s2.g, s.s2.b, s.s2.a);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double s.s1.r 0.0
+uniform float s.s2.p1 1.0
+uniform double s.s2.g 1.0
+uniform double s.s2.b 0.0
+uniform float s.s2.p2 1.0
+uniform double s.s2.a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test
new file mode 100644
index 0000000..0889bd5
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test
@@ -0,0 +1,38 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+        double d1;
+	dvec2  d2;
+        dvec3  d3;
+        dvec4  d4;
+};
+
+out vec4 color;
+
+void main()
+{
+	dvec4 result = dvec4(d1, d2.y, d3.z, d4.w + arg0);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.1 0.3 0.6 1.25
+uniform double d1 0.1
+uniform dvec2  d2 0.2 0.3
+uniform dvec3  d3 0.4 0.5 0.6
+uniform dvec4  d4 0.7 0.8 0.9 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
\ No newline at end of file
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test
new file mode 100644
index 0000000..c5ae503
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test
@@ -0,0 +1,38 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int index;
+uniform ubo1 {
+	double data[8];
+};
+
+out vec4 color;
+
+void main()
+{
+        dvec4 result = dvec4(data[index] + arg0);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.55 0.55 0.55 0.55
+uniform int index 2
+uniform double data[0] 0.1
+uniform double data[1] 0.2
+uniform double data[2] 0.3
+uniform double data[3] 0.4
+
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test
new file mode 100644
index 0000000..774370d
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test
@@ -0,0 +1,34 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double tolerance;
+uniform dvec4 expected;
+uniform int index;
+uniform ubo1 {
+	dvec4 data[4];
+};
+
+out vec4 color;
+
+void main()
+{
+	dvec4 result = data[index];
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 0.30 0.31 0.32 0.33
+uniform int index 2
+uniform dvec4 data[0] 0.10 0.11 0.12 0.13
+uniform dvec4 data[1] 0.20 0.21 0.22 0.23
+uniform dvec4 data[2] 0.30 0.31 0.32 0.33
+uniform dvec4 data[3] 0.40 0.41 0.42 0.43
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test
new file mode 100644
index 0000000..b2de98e
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test
@@ -0,0 +1,37 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int index;
+uniform ubo1 {
+	dvec4 data[4];
+};
+
+out vec4 color;
+
+void main()
+{
+        dvec4 result = dvec4(data[index].z + arg0);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.47 0.47 0.47 0.47
+uniform int index 1
+uniform dvec4 data[0] 0.10 0.11 0.12 0.13
+uniform dvec4 data[1] 0.20 0.21 0.22 0.23
+uniform dvec4 data[2] 0.30 0.31 0.32 0.33
+uniform dvec4 data[3] 0.40 0.41 0.42 0.43
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test
new file mode 100644
index 0000000..cb57d11
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test
@@ -0,0 +1,52 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+struct S {
+	double d1[2];
+	dvec3  d3[2];
+};
+
+uniform int index1;
+uniform int index2;
+uniform ubo1 {
+	S data[2];
+};
+
+out vec4 color;
+
+void main()
+{
+        dvec4 result = dvec4(data[index1].d3[index2], arg0);
+        color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.70 0.71 0.72 0.25
+
+uniform int index1 1
+uniform int index2 1
+
+uniform double data[0].d1[0] 0.0
+uniform dvec3  data[0].d1[1] 0.1
+uniform double data[0].d3[0] 0.20 0.21 0.22
+uniform dvec3  data[0].d3[1] 0.30 0.31 0.32
+
+uniform double data[1].d1[0] 0.4
+uniform dvec3  data[1].d1[1] 0.5
+uniform double data[1].d3[0] 0.60 0.61 0.62
+uniform dvec3  data[1].d3[1] 0.70 0.71 0.72
+
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
\ No newline at end of file
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test
new file mode 100644
index 0000000..acf7131
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test
@@ -0,0 +1,69 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int i;
+uniform ubo1 {
+        dvec4 colors[4];
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+        dvec4 temp[4] = colors;
+        temp[0] = dvec4(1.0, 0.0, 0.0, arg0);
+        dvec4 result = temp[i];
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int j = 0; j < 3; j++) {
+            gl_Position = vertex_to_gs[j];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+        color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.0 1.0 0.0 0.0
+uniform int i 1
+uniform dvec4 colors[0] 0.0 0.0 0.0 0.0
+uniform dvec4 colors[1] 0.0 1.0 0.0 0.0
+uniform dvec4 colors[2] 0.0 1.0 1.0 0.0
+uniform dvec4 colors[3] 1.0 0.0 1.0 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test
new file mode 100644
index 0000000..7eaa1bf
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test
@@ -0,0 +1,60 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+	layout(row_major) dmat4 m;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+	dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+uniform dmat4 m 0.25 0.0 0.0 0.0   0.0 0.0 0.75 0.0   0.0 0.5 0.0 0.0   0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test
new file mode 100644
index 0000000..5f0825b
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test
@@ -0,0 +1,60 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+	dmat4 m;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+        dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+uniform dmat4 m 0.25 0.0 0.0 0.0   0.0 0.0 0.75 0.0   0.0 0.5 0.0 0.0   0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test
new file mode 100644
index 0000000..20ff3a3
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test
@@ -0,0 +1,63 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+	double d[4];
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+	dvec4 result = dvec4(d[0] + arg0, d[1], d[2], d[3]);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test
new file mode 100644
index 0000000..840de49
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test
@@ -0,0 +1,71 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int ri, gi, bi, ai;
+
+uniform ubo1 {
+	double d[4];
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+	dvec4 result = dvec4(d[ri] + arg0, d[gi], d[bi], d[ai]);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+
+uniform int ri 0
+uniform int gi 1
+uniform int bi 2
+uniform int ai 3
+
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test
new file mode 100644
index 0000000..3f44122
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test
@@ -0,0 +1,65 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg0;
+uniform bool arg1;
+uniform double arg2;
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+        dvec4 result;
+	if (arg1)
+		result = dvec4(arg0, arg2, 0.0, 0.0);
+	else
+		result = dvec4(arg0, arg2, 1.0, 0.0);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+                gl_Position = vertex_to_gs[i];
+                EmitVertex();
+        }
+
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 1.0 1.0 0.0 0.0
+uniform double arg0 1.0
+uniform int arg1 1
+uniform double arg2 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..b4e0e75
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,64 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg[7];
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+	dvec4 result =  dvec4(arg[int(arg[6])] + arg0);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.65 0.65 0.65 0.65
+uniform double arg[0] 0.1
+uniform double arg[1] 0.2
+uniform double arg[2] 0.3
+uniform double arg[3] 0.4
+uniform double arg[4] 0.5
+uniform double arg[5] 0.6
+uniform double arg[6] 3.0
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test
new file mode 100644
index 0000000..2d29464
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test
@@ -0,0 +1,66 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+  double r;
+  float g;
+  double b;
+  double a;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+	dvec4 result = dvec4(r + arg0, g, b, a);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 1.0 0.0
+uniform double r 0.0
+uniform float g 1.0
+uniform double b 1.0
+uniform double a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..ff1d5f9
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,62 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform dvec4 arg[7];
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+	dvec4 result = dvec4(arg[int(arg[6].w)]);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 0.40 0.41 0.42 0.43
+uniform dvec4 arg[0] 0.10 0.11 0.12 0.13
+uniform dvec4 arg[1] 0.20 0.21 0.22 0.23
+uniform dvec4 arg[2] 0.30 0.31 0.32 0.33
+uniform dvec4 arg[3] 0.40 0.41 0.42 0.43
+uniform dvec4 arg[4] 0.50 0.51 0.52 0.53
+uniform dvec4 arg[5] 0.60 0.61 0.62 0.63
+uniform dvec4 arg[6] 0.70 0.71 0.72 3.00
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test
new file mode 100644
index 0000000..b9ebc6e
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test
@@ -0,0 +1,83 @@ 
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+        vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+struct S1 {
+	double r;
+};
+
+struct S2 {
+	float p1;
+	double r;
+        double g;
+        double b;
+        float p2;
+	double a;
+};
+
+struct S {
+       S1 s1;
+       S2 s2;
+};
+
+uniform ubo1 {
+	S s;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+        dvec4 result = dvec4(s.s1.r + arg0, s.s2.g, s.s2.b, s.s2.a);
+        v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+        for (int i = 0; i < 3; i++) {
+            gl_Position = vertex_to_gs[i];
+            EmitVertex();
+        }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+	color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double s.s1.r 0.0
+uniform float s.s2.p1 1.0
+uniform double s.s2.g 1.0
+uniform double s.s2.b 0.0
+uniform float s.s2.p2 1.0
+uniform double s.s2.a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0