Add to tests/spec/glsl-es-1.00/compiler/structure-and-array-operations a series of array declaration size tests.
Signed-off-by: Tom Gall <[email protected]> --- .../array-size-bool.vert | 16 ++ .../array-size-bvec2.vert | 16 ++ .../array-size-bvec3.vert | 16 ++ .../array-size-bvec4.vert | 16 ++ .../array-size-constant-cast.vert | 17 +++ .../array-size-constant-relational.vert | 161 ++++++++++++++++++++ .../array-size-float.vert | 16 ++ .../array-size-int.vert | 16 ++ .../array-size-ivec2.vert | 16 ++ .../array-size-ivec3.vert | 16 ++ .../array-size-ivec4.vert | 16 ++ .../array-size-length.vert | 17 +++ .../array-size-negative.vert | 16 ++ .../array-size-non-builtin-function.vert | 18 +++ .../array-size-not-constant.vert | 17 +++ .../array-size-selection.vert | 21 +++ .../array-size-sequence-in-parenthesis.vert | 29 ++++ .../array-size-sequence.vert | 29 ++++ .../array-size-vec2.vert | 16 ++ .../array-size-vec3.vert | 16 ++ .../array-size-vec4.vert | 16 ++ .../array-size-with-side-effect.vert | 19 +++ .../array-size-zero.vert | 16 ++ 23 files changed, 552 insertions(+) create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bool.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec2.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec3.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec4.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-cast.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-relational.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-float.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-int.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec2.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec3.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec4.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-length.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-negative.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-non-builtin-function.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-not-constant.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-selection.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence-in-parenthesis.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec2.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec3.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec4.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-with-side-effect.vert create mode 100644 tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-zero.vert 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 0000000..06d451b --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bool.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..c52d636 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec2.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..47db72e --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec3.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..f87cbed --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-bvec4.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..9daf4a3 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-cast.vert @@ -0,0 +1,17 @@ +/* [config] + * expect_result: pass + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..de5a931 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-constant-relational.vert @@ -0,0 +1,161 @@ +/* [config] + * expect_result: pass + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..80f4cd7 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-float.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..0b7ce81 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-int.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: pass + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..0828024 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec2.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..4f3b212 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec3.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..920444f --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-ivec4.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..afa6d47 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-length.vert @@ -0,0 +1,17 @@ +/* [config] + * expect_result: pass + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..be439fe --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-negative.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..23abb99 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-non-builtin-function.vert @@ -0,0 +1,18 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..631a4bc --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-not-constant.vert @@ -0,0 +1,17 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..54c0a98 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-selection.vert @@ -0,0 +1,21 @@ +/* [config] + * expect_result: pass + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral Constant Expressions") greater than + * zero." + */ + + +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 0000000..43267c6 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence-in-parenthesis.vert @@ -0,0 +1,29 @@ +/* [config] + * expect_result: fail + * glsl_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 constant_expression RIGHT_BRACKET + * 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 0000000..cf325f6 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-sequence.vert @@ -0,0 +1,29 @@ +/* [config] + * expect_result: fail + * glsl_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 constant_expression RIGHT_BRACKET + * 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 0000000..9c01854 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec2.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..d1936dd --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec3.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..06a5ab3 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-vec4.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..f0a5564 --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-with-side-effect.vert @@ -0,0 +1,19 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral 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 0000000..156eeae --- /dev/null +++ b/tests/spec/glsl-es-1.00/compiler/structure-and-array-operations/array-size-zero.vert @@ -0,0 +1,16 @@ +/* [config] + * expect_result: fail + * glsl_version: 1.00 + * [end config] + * + * Page 24, GLSL ES 1.00 spec: + * + * "The array size must be an integral constant expression (see + * Section 4.3.3 "Integral Constant Expressions") greater than + * zero." + */ + + +uniform vec4 [0] a; + +void main() { gl_Position = vec4(0.0); } -- 1.7.10.4 _______________________________________________ Piglit mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/piglit
