data/gles31/shaders/gl45/linkage_geometry.test - third_party/vulkan-cts - Git at Google

 # -------------------------------------------------
 # drawElements Quality Program OpenGL ES 3.2 Module
 # -------------------------------------------------
 #
 # Copyright 2016 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.


 group varying "Varying linkage"
 	group rules "Rules"
 		case input_type_mismatch
 			version 450
 			desc "Geometry shader input type mismatch"
 			expect link_fail
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out mediump float geo_in;
 				void main()
 				{
 					geo_in = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in mediump vec2 geo_in[];
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = geo_in[ndx].x + geo_in[ndx].y;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_different_precision
 			version 450
 			desc "Geometry shader input precision mismatch"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out highp float geo_in;
 				void main()
 				{
 					geo_in = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in lowp float geo_in[];
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = geo_in[ndx];
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case output_different_precision
 			version 450
 			desc "Geometry shader output precision mismatch"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				out highp float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = 1.0;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in lowp float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_superfluous_declaration
 			version 450
 			desc "Geometry shader has no input for an output"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out mediump float geo_in;
 				void main()
 				{
 					geo_in = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = 1.0;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case output_superfluous_declaration
 			version 450
 			desc "Geometry shader has output without an matching input"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = 1.0;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				void main()
 				{
 					out0 = 1.0;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_array_explicit_size
 			version 450
 			desc "Geometry shader input is explicitly sized array"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out mediump float geo_in;
 				void main()
 				{
 					geo_in = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in mediump float geo_in[3];
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = geo_in[ndx];
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_non_array
 			version 450
 			desc "Geometry shader has no input for an output"
 			expect compile_or_link_fail
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out mediump float geo_in;
 				void main()
 				{
 					geo_in = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in mediump float geo_in;
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = geo_in;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_array_size_mismatch
 			version 450
 			desc "Geometry shader input is explicitly sized array, but size does not match input primitive"
 			expect compile_or_link_fail
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out mediump float geo_in;
 				void main()
 				{
 					geo_in = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in mediump float geo_in[4];
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = geo_in[ndx+1];
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_block
 			version 450
 			desc "Geometry shader input block"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out IOBlockName
 				{
 					mediump float var;
 				} outputInstanceName;
 				void main()
 				{
 					outputInstanceName.var = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in IOBlockName
 				{
 					mediump float var;
 				} inputInstanceName[];
 				out mediump float geo_out;
 				void main()
 				{
 					geo_out = inputInstanceName[0].var;
 					gl_Position = gl_in[0].gl_Position;
 					EmitVertex();
 					geo_out = inputInstanceName[1].var;
 					gl_Position = gl_in[1].gl_Position;
 					EmitVertex();
 					geo_out = inputInstanceName[2].var;
 					gl_Position = gl_in[2].gl_Position;
 					EmitVertex();
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_block_explicit_size
 			version 450
 			desc "Geometry shader input block with explicit size"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out IOBlockName
 				{
 					mediump float var;
 				} outputInstanceName;
 				void main()
 				{
 					outputInstanceName.var = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in IOBlockName
 				{
 					mediump float var;
 				} inputInstanceName[3];
 				out mediump float geo_out;
 				void main()
 				{
 					geo_out = inputInstanceName[0].var;
 					gl_Position = gl_in[0].gl_Position;
 					EmitVertex();
 					geo_out = inputInstanceName[1].var;
 					gl_Position = gl_in[1].gl_Position;
 					EmitVertex();
 					geo_out = inputInstanceName[2].var;
 					gl_Position = gl_in[2].gl_Position;
 					EmitVertex();
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_block_non_array
 			version 450
 			desc "Geometry shader input block is non an array"
 			expect compile_or_link_fail
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out IOBlockName
 				{
 					mediump float var;
 				} outputInstanceName;
 				void main()
 				{
 					outputInstanceName.var = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in IOBlockName
 				{
 					mediump float var;
 				} inputInstanceName;
 				out mediump float geo_out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_out = inputInstanceName.var;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case input_block_array_size_mismatch
 			version 450
 			desc "Geometry shader input block invalid array size"
 			expect compile_or_link_fail
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				out IOBlockName
 				{
 					mediump float var;
 				} outputInstanceName;
 				void main()
 				{
 					outputInstanceName.var = 1.0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				in IOBlockName
 				{
 					mediump float var;
 				} inputInstanceName[4];
 				out mediump float geo_out;
 				void main()
 				{
 					geo_out = inputInstanceName[0].var;
 					gl_Position = gl_in[0].gl_Position;
 					EmitVertex();
 					geo_out = inputInstanceName[1].var;
 					gl_Position = gl_in[1].gl_Position;
 					EmitVertex();
 					geo_out = inputInstanceName[2].var + inputInstanceName[3].var;
 					gl_Position = gl_in[2].gl_Position;
 					EmitVertex();
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in mediump float geo_out;
 				void main()
 				{
 					out0 = geo_out;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case output_block
 			version 450
 			desc "Geometry shader output block"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				out IOBlockName
 				{
 					mediump float var;
 				} outputInstanceName;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						outputInstanceName.var = 1.0;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in IOBlockName
 				{
 					mediump float var;
 				} inputInstanceName;
 				void main()
 				{
 					out0 = inputInstanceName.var;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case output_block_array
 			version 450
 			desc "Geometry shader output block array"
 			values { output float out0 = 1.0; }
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				out IOBlockName
 				{
 					mediump float var;
 				} outputInstanceName[2];
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						outputInstanceName[0].var = 2.0;
 						outputInstanceName[1].var = 1.0;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in IOBlockName
 				{
 					mediump float var;
 				} inputInstanceName[2];
 				void main()
 				{
 					out0 = inputInstanceName[0].var - inputInstanceName[1].var;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case unspecified_input_primitive_type
 			version 450
 			desc "Geometry shader input type unspecified"
 			expect compile_or_link_fail
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				layout (triangle_strip, max_vertices=3) out;
 				void main()
 				{
 					gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
 					EmitVertex();
 					gl_Position = vec4(0.0, 1.0, 0.0, 1.0);
 					EmitVertex();
 					gl_Position = vec4(1.0, 1.0, 0.0, 1.0);
 					EmitVertex();
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				void main()
 				{
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case unspecified_output_primitive_type
 			version 450
 			desc "Geometry shader output type unspecified"
 			expect compile_or_link_fail
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				layout (triangles) in;
 				layout (max_vertices=3) out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				void main()
 				{
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case unspecified_output_primitive_num_vertices
 			version 450
 			desc "Geometry shader output type unspecified"
 			expect compile_or_link_fail
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				layout (triangles) in;
 				layout (triangle_strip) out;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				void main()
 				{
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		# access_more_than_available_input_vertices
 		case access_more_than_available_input_vertices
 			version 450
 			desc "Geometry shader input block with explicit size"
 			expect compile_or_link_fail
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				void main()
 				{
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				void main()
 				{
 					gl_Position = gl_in[0].gl_Position;
 					EmitVertex();
 					gl_Position = gl_in[1].gl_Position;
 					EmitVertex();
 					gl_Position = gl_in[4].gl_Position; // access more than available
 					EmitVertex();
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				void main()
 				{
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end
 	end

 	import "linkage_geometry_varying_types.test"

 	group qualifiers "Varying qualifiers"
 		case smooth
 			version 450
 			desc "varying with smooth interpolation"
 			values
 			{
 				input float in0		= 1.0;
 				output float out0	= 1.0;
 			}
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				smooth out mediump float vtx_var;
 				void main()
 				{
 					vtx_var = in0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				smooth in mediump float vtx_var[];
 				smooth out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx];
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				smooth in float geo_var;
 				void main()
 				{
 					out0 = geo_var;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case flat
 			version 450
 			desc "varying with flat interpolation"
 			values
 			{
 				input float in0		= 1.0;
 				output float out0	= 1.0;
 			}
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				flat out mediump float vtx_var;
 				void main()
 				{
 					vtx_var = in0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				flat in mediump float vtx_var[];
 				flat out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx];
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				flat in float geo_var;
 				void main()
 				{
 					out0 = geo_var;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case centroid
 			version 450
 			desc "varying declared with centroid qualifier"
 			values
 			{
 				input float in0		= 1.0;
 				output float out0	= 1.0;
 			}
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				centroid out mediump float vtx_var;
 				void main()
 				{
 					vtx_var = in0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				centroid in mediump float vtx_var[];
 				centroid out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx];
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				centroid in float geo_var;
 				void main()
 				{
 					out0 = geo_var;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end

 		case sample
 			version 450
 			desc "varying declared with sample qualifier"
 			values
 			{
 				input float in0		= 1.0;
 				output float out0	= 1.0;
 			}
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				sample out mediump float vtx_var;
 				void main()
 				{
 					vtx_var = in0;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				sample in mediump float vtx_var[];
 				sample out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx];
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				sample in float geo_var;
 				void main()
 				{
 					out0 = geo_var;
 					${FRAGMENT_OUTPUT}
 				}
 			""
 		end
 	end
 end

 group uniform "Uniform linkage"
 	group rules "Rules"

 		case type_mismatch_1
 			version 450
 			desc "uniforms declared with different types"
 			expect link_fail
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				uniform mediump float u_var;
 				out mediump float vtx_var;
 				void main()
 				{
 					vtx_var = u_var;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				uniform mediump vec4 u_var;
 				in mediump float vtx_var[];
 				out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx];
 						gl_Position = gl_in[ndx].gl_Position + u_var;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in float geo_var;
 				void main()
 				{
 					${FRAG_COLOR} = vec4(geo_var);
 				}
 			""
 		end

 		case type_mismatch_2
 			version 450
 			desc "uniforms declared with different types"
 			expect link_fail
 			require limit "GL_MAX_VERTEX_ATOMIC_COUNTERS" > 0
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				layout(binding=0) uniform atomic_uint u_var;
 				out mediump float vtx_var;
 				void main()
 				{
 					uint result = atomicCounterIncrement(u_var);
 					vtx_var = float(result);
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				uniform mediump vec4 u_var;
 				in mediump float vtx_var[];
 				out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx];
 						gl_Position = gl_in[ndx].gl_Position + u_var;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in float geo_var;
 				void main()
 				{
 					${FRAG_COLOR} = vec4(geo_var);
 				}
 			""
 		end

 		case type_mismatch_3
 			version 450
 			desc "uniforms declared with different types"
 			expect link_fail
 			require limit "GL_MAX_VERTEX_IMAGE_UNIFORMS" > 0
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				layout(binding=0) layout(rgba8i) uniform readonly highp iimage2D u_var;
 				out mediump float vtx_var;
 				void main()
 				{
 					int result = imageSize(u_var).x;
 					vtx_var = float(result);
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				uniform mediump vec4 u_var;
 				in mediump float vtx_var[];
 				out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx];
 						gl_Position = gl_in[ndx].gl_Position + u_var;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				in float geo_var;
 				void main()
 				{
 					${FRAG_COLOR} = vec4(geo_var);
 				}
 			""
 		end

 		case struct_partial_usage
 			version 450
 			desc "uniforms struct used partially in different stages"
 			values
 			{
 				uniform float val.vtxValue	= 1.0;
 				uniform float val.geoValue	= 1.0;
 				uniform float val.frgValue	= 1.0;
 			}
 			vertex ""
 				#version 450
 				${VERTEX_DECLARATIONS}
 				struct S
 				{
 					mediump float vtxValue;
 					mediump float geoValue;
 					mediump float frgValue;
 				};
 				uniform S val;
 				out mediump float vtx_var;
 				void main()
 				{
 					vtx_var = val.vtxValue;
 					${VERTEX_OUTPUT}
 				}
 			""
 			geometry ""
 				#version 450
 				${GEOMETRY_DECLARATIONS}
 				struct S
 				{
 					mediump float vtxValue;
 					mediump float geoValue;
 					mediump float frgValue;
 				};
 				uniform S val;
 				in mediump float vtx_var[];
 				out mediump float geo_var;
 				void main()
 				{
 					for (int ndx = 0; ndx < gl_in.length(); ++ndx)
 					{
 						geo_var = vtx_var[ndx] + val.geoValue;
 						gl_Position = gl_in[ndx].gl_Position;
 						EmitVertex();
 					}
 				}
 			""
 			fragment ""
 				#version 450
 				precision mediump float;
 				${FRAGMENT_DECLARATIONS}
 				struct S
 				{
 					mediump float vtxValue;
 					mediump float geoValue;
 					mediump float frgValue;
 				};
 				uniform S val;
 				in float geo_var;
 				void main()
 				{
 					${FRAG_COLOR} = vec4(geo_var + val.frgValue);
 				}
 			""
 		end
 	end

 	import "linkage_geometry_uniform_types.test"
 end
	# -------------------------------------------------
	# drawElements Quality Program OpenGL ES 3.2 Module
	# -------------------------------------------------
	#
	# Copyright 2016 The Android Open Source Project
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.


	group varying "Varying linkage"
	group rules "Rules"
	case input_type_mismatch
	version 450
	desc "Geometry shader input type mismatch"
	expect link_fail
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out mediump float geo_in;
	void main()
	{
	geo_in = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in mediump vec2 geo_in[];
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = geo_in[ndx].x + geo_in[ndx].y;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_different_precision
	version 450
	desc "Geometry shader input precision mismatch"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out highp float geo_in;
	void main()
	{
	geo_in = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in lowp float geo_in[];
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = geo_in[ndx];
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case output_different_precision
	version 450
	desc "Geometry shader output precision mismatch"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	out highp float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = 1.0;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in lowp float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_superfluous_declaration
	version 450
	desc "Geometry shader has no input for an output"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out mediump float geo_in;
	void main()
	{
	geo_in = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = 1.0;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case output_superfluous_declaration
	version 450
	desc "Geometry shader has output without an matching input"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = 1.0;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	void main()
	{
	out0 = 1.0;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_array_explicit_size
	version 450
	desc "Geometry shader input is explicitly sized array"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out mediump float geo_in;
	void main()
	{
	geo_in = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in mediump float geo_in[3];
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = geo_in[ndx];
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_non_array
	version 450
	desc "Geometry shader has no input for an output"
	expect compile_or_link_fail
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out mediump float geo_in;
	void main()
	{
	geo_in = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in mediump float geo_in;
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = geo_in;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_array_size_mismatch
	version 450
	desc "Geometry shader input is explicitly sized array, but size does not match input primitive"
	expect compile_or_link_fail
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out mediump float geo_in;
	void main()
	{
	geo_in = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in mediump float geo_in[4];
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = geo_in[ndx+1];
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_block
	version 450
	desc "Geometry shader input block"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out IOBlockName
	{
	mediump float var;
	} outputInstanceName;
	void main()
	{
	outputInstanceName.var = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in IOBlockName
	{
	mediump float var;
	} inputInstanceName[];
	out mediump float geo_out;
	void main()
	{
	geo_out = inputInstanceName[0].var;
	gl_Position = gl_in[0].gl_Position;
	EmitVertex();
	geo_out = inputInstanceName[1].var;
	gl_Position = gl_in[1].gl_Position;
	EmitVertex();
	geo_out = inputInstanceName[2].var;
	gl_Position = gl_in[2].gl_Position;
	EmitVertex();
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_block_explicit_size
	version 450
	desc "Geometry shader input block with explicit size"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out IOBlockName
	{
	mediump float var;
	} outputInstanceName;
	void main()
	{
	outputInstanceName.var = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in IOBlockName
	{
	mediump float var;
	} inputInstanceName[3];
	out mediump float geo_out;
	void main()
	{
	geo_out = inputInstanceName[0].var;
	gl_Position = gl_in[0].gl_Position;
	EmitVertex();
	geo_out = inputInstanceName[1].var;
	gl_Position = gl_in[1].gl_Position;
	EmitVertex();
	geo_out = inputInstanceName[2].var;
	gl_Position = gl_in[2].gl_Position;
	EmitVertex();
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_block_non_array
	version 450
	desc "Geometry shader input block is non an array"
	expect compile_or_link_fail
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out IOBlockName
	{
	mediump float var;
	} outputInstanceName;
	void main()
	{
	outputInstanceName.var = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in IOBlockName
	{
	mediump float var;
	} inputInstanceName;
	out mediump float geo_out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_out = inputInstanceName.var;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case input_block_array_size_mismatch
	version 450
	desc "Geometry shader input block invalid array size"
	expect compile_or_link_fail
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	out IOBlockName
	{
	mediump float var;
	} outputInstanceName;
	void main()
	{
	outputInstanceName.var = 1.0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	in IOBlockName
	{
	mediump float var;
	} inputInstanceName[4];
	out mediump float geo_out;
	void main()
	{
	geo_out = inputInstanceName[0].var;
	gl_Position = gl_in[0].gl_Position;
	EmitVertex();
	geo_out = inputInstanceName[1].var;
	gl_Position = gl_in[1].gl_Position;
	EmitVertex();
	geo_out = inputInstanceName[2].var + inputInstanceName[3].var;
	gl_Position = gl_in[2].gl_Position;
	EmitVertex();
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in mediump float geo_out;
	void main()
	{
	out0 = geo_out;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case output_block
	version 450
	desc "Geometry shader output block"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	out IOBlockName
	{
	mediump float var;
	} outputInstanceName;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	outputInstanceName.var = 1.0;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in IOBlockName
	{
	mediump float var;
	} inputInstanceName;
	void main()
	{
	out0 = inputInstanceName.var;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case output_block_array
	version 450
	desc "Geometry shader output block array"
	values { output float out0 = 1.0; }
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	out IOBlockName
	{
	mediump float var;
	} outputInstanceName[2];
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	outputInstanceName[0].var = 2.0;
	outputInstanceName[1].var = 1.0;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in IOBlockName
	{
	mediump float var;
	} inputInstanceName[2];
	void main()
	{
	out0 = inputInstanceName[0].var - inputInstanceName[1].var;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case unspecified_input_primitive_type
	version 450
	desc "Geometry shader input type unspecified"
	expect compile_or_link_fail
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	layout (triangle_strip, max_vertices=3) out;
	void main()
	{
	gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
	EmitVertex();
	gl_Position = vec4(0.0, 1.0, 0.0, 1.0);
	EmitVertex();
	gl_Position = vec4(1.0, 1.0, 0.0, 1.0);
	EmitVertex();
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	void main()
	{
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case unspecified_output_primitive_type
	version 450
	desc "Geometry shader output type unspecified"
	expect compile_or_link_fail
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	layout (triangles) in;
	layout (max_vertices=3) out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	void main()
	{
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case unspecified_output_primitive_num_vertices
	version 450
	desc "Geometry shader output type unspecified"
	expect compile_or_link_fail
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	layout (triangles) in;
	layout (triangle_strip) out;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	void main()
	{
	${FRAGMENT_OUTPUT}
	}
	""
	end

	# access_more_than_available_input_vertices
	case access_more_than_available_input_vertices
	version 450
	desc "Geometry shader input block with explicit size"
	expect compile_or_link_fail
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	void main()
	{
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	void main()
	{
	gl_Position = gl_in[0].gl_Position;
	EmitVertex();
	gl_Position = gl_in[1].gl_Position;
	EmitVertex();
	gl_Position = gl_in[4].gl_Position; // access more than available
	EmitVertex();
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	void main()
	{
	${FRAGMENT_OUTPUT}
	}
	""
	end
	end

	import "linkage_geometry_varying_types.test"

	group qualifiers "Varying qualifiers"
	case smooth
	version 450
	desc "varying with smooth interpolation"
	values
	{
	input float in0 = 1.0;
	output float out0 = 1.0;
	}
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	smooth out mediump float vtx_var;
	void main()
	{
	vtx_var = in0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	smooth in mediump float vtx_var[];
	smooth out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx];
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	smooth in float geo_var;
	void main()
	{
	out0 = geo_var;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case flat
	version 450
	desc "varying with flat interpolation"
	values
	{
	input float in0 = 1.0;
	output float out0 = 1.0;
	}
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	flat out mediump float vtx_var;
	void main()
	{
	vtx_var = in0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	flat in mediump float vtx_var[];
	flat out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx];
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	flat in float geo_var;
	void main()
	{
	out0 = geo_var;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case centroid
	version 450
	desc "varying declared with centroid qualifier"
	values
	{
	input float in0 = 1.0;
	output float out0 = 1.0;
	}
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	centroid out mediump float vtx_var;
	void main()
	{
	vtx_var = in0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	centroid in mediump float vtx_var[];
	centroid out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx];
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	centroid in float geo_var;
	void main()
	{
	out0 = geo_var;
	${FRAGMENT_OUTPUT}
	}
	""
	end

	case sample
	version 450
	desc "varying declared with sample qualifier"
	values
	{
	input float in0 = 1.0;
	output float out0 = 1.0;
	}
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	sample out mediump float vtx_var;
	void main()
	{
	vtx_var = in0;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	sample in mediump float vtx_var[];
	sample out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx];
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	sample in float geo_var;
	void main()
	{
	out0 = geo_var;
	${FRAGMENT_OUTPUT}
	}
	""
	end
	end
	end

	group uniform "Uniform linkage"
	group rules "Rules"

	case type_mismatch_1
	version 450
	desc "uniforms declared with different types"
	expect link_fail
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	uniform mediump float u_var;
	out mediump float vtx_var;
	void main()
	{
	vtx_var = u_var;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	uniform mediump vec4 u_var;
	in mediump float vtx_var[];
	out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx];
	gl_Position = gl_in[ndx].gl_Position + u_var;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in float geo_var;
	void main()
	{
	${FRAG_COLOR} = vec4(geo_var);
	}
	""
	end

	case type_mismatch_2
	version 450
	desc "uniforms declared with different types"
	expect link_fail
	require limit "GL_MAX_VERTEX_ATOMIC_COUNTERS" > 0
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	layout(binding=0) uniform atomic_uint u_var;
	out mediump float vtx_var;
	void main()
	{
	uint result = atomicCounterIncrement(u_var);
	vtx_var = float(result);
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	uniform mediump vec4 u_var;
	in mediump float vtx_var[];
	out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx];
	gl_Position = gl_in[ndx].gl_Position + u_var;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in float geo_var;
	void main()
	{
	${FRAG_COLOR} = vec4(geo_var);
	}
	""
	end

	case type_mismatch_3
	version 450
	desc "uniforms declared with different types"
	expect link_fail
	require limit "GL_MAX_VERTEX_IMAGE_UNIFORMS" > 0
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	layout(binding=0) layout(rgba8i) uniform readonly highp iimage2D u_var;
	out mediump float vtx_var;
	void main()
	{
	int result = imageSize(u_var).x;
	vtx_var = float(result);
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	uniform mediump vec4 u_var;
	in mediump float vtx_var[];
	out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx];
	gl_Position = gl_in[ndx].gl_Position + u_var;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	in float geo_var;
	void main()
	{
	${FRAG_COLOR} = vec4(geo_var);
	}
	""
	end

	case struct_partial_usage
	version 450
	desc "uniforms struct used partially in different stages"
	values
	{
	uniform float val.vtxValue = 1.0;
	uniform float val.geoValue = 1.0;
	uniform float val.frgValue = 1.0;
	}
	vertex ""
	#version 450
	${VERTEX_DECLARATIONS}
	struct S
	{
	mediump float vtxValue;
	mediump float geoValue;
	mediump float frgValue;
	};
	uniform S val;
	out mediump float vtx_var;
	void main()
	{
	vtx_var = val.vtxValue;
	${VERTEX_OUTPUT}
	}
	""
	geometry ""
	#version 450
	${GEOMETRY_DECLARATIONS}
	struct S
	{
	mediump float vtxValue;
	mediump float geoValue;
	mediump float frgValue;
	};
	uniform S val;
	in mediump float vtx_var[];
	out mediump float geo_var;
	void main()
	{
	for (int ndx = 0; ndx < gl_in.length(); ++ndx)
	{
	geo_var = vtx_var[ndx] + val.geoValue;
	gl_Position = gl_in[ndx].gl_Position;
	EmitVertex();
	}
	}
	""
	fragment ""
	#version 450
	precision mediump float;
	${FRAGMENT_DECLARATIONS}
	struct S
	{
	mediump float vtxValue;
	mediump float geoValue;
	mediump float frgValue;
	};
	uniform S val;
	in float geo_var;
	void main()
	{
	${FRAG_COLOR} = vec4(geo_var + val.frgValue);
	}
	""
	end
	end

	import "linkage_geometry_uniform_types.test"
	end