Home | History | Annotate | Download | only in functional 
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program OpenGL ES 3.1 Module
      3  * -------------------------------------------------
      4  *
      5  * Copyright 2017 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief Negative ShaderFramebufferFetch tests.
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "es31fNegativeShaderFramebufferFetchTests.hpp"
     25 #include "gluContextInfo.hpp"
     26 #include "gluShaderProgram.hpp"
     27 #include "tcuStringTemplate.hpp"
     28 
     29 namespace deqp
     30 {
     31 
     32 using std::string;
     33 using std::map;
     34 
     35 namespace gles31
     36 {
     37 namespace Functional
     38 {
     39 namespace NegativeTestShared
     40 {
     41 namespace
     42 {
     43 
     44 static const char* vertexShaderSource		=	"${GLSL_VERSION_STRING}\n"
     45 												"\n"
     46 												"void main (void)\n"
     47 												"{\n"
     48 												"	gl_Position = vec4(0.0);\n"
     49 												"}\n";
     50 
     51 static const char* fragmentShaderSource		=	"${GLSL_VERSION_STRING}\n"
     52 												"layout(location = 0) out mediump vec4 fragColor;\n"
     53 												"\n"
     54 												"void main (void)\n"
     55 												"{\n"
     56 												"	fragColor = vec4(1.0);\n"
     57 												"}\n";
     58 
     59 static void checkExtensionSupport (NegativeTestContext& ctx, const char* extName)
     60 {
     61 	if (!ctx.getContextInfo().isExtensionSupported(extName))
     62 		throw tcu::NotSupportedError(string(extName) + " not supported");
     63 }
     64 
     65 static void checkFramebufferFetchSupport (NegativeTestContext& ctx)
     66 {
     67 	checkExtensionSupport(ctx, "GL_EXT_shader_framebuffer_fetch");
     68 }
     69 
     70 enum ProgramError
     71 {
     72 	PROGRAM_ERROR_LINK = 0,
     73 	PROGRAM_ERROR_COMPILE,
     74 	PROGRAM_ERROR_COMPILE_OR_LINK,
     75 };
     76 
     77 void verifyProgramError (NegativeTestContext& ctx, const glu::ShaderProgram& program,  ProgramError error, glu::ShaderType shaderType)
     78 {
     79 	bool	testFailed = false;
     80 	string	message;
     81 
     82 	ctx.getLog() << program;
     83 
     84 	switch (error)
     85 	{
     86 		case PROGRAM_ERROR_LINK:
     87 		{
     88 			message = "Program was not expected to link.";
     89 			testFailed = (program.getProgramInfo().linkOk);
     90 			break;
     91 		}
     92 		case PROGRAM_ERROR_COMPILE:
     93 		{
     94 			message = "Program was not expected to compile.";
     95 			testFailed = program.getShaderInfo(shaderType).compileOk;
     96 			break;
     97 		}
     98 		case PROGRAM_ERROR_COMPILE_OR_LINK:
     99 		{
    100 			message = "Program was not expected to compile or link.";
    101 			testFailed = (program.getProgramInfo().linkOk) && (program.getShaderInfo(shaderType).compileOk);
    102 			break;
    103 		}
    104 		default:
    105 		{
    106 			DE_FATAL("Invalid program error type");
    107 			break;
    108 		}
    109 	}
    110 
    111 	if (testFailed)
    112 	{
    113 		ctx.getLog() << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
    114 		ctx.fail(message);
    115 	}
    116 }
    117 
    118 void last_frag_data_not_defined (NegativeTestContext& ctx)
    119 {
    120 	checkFramebufferFetchSupport(ctx);
    121 
    122 	const bool					isES32	= glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
    123 	map<string, string>			args;
    124 	args["GLSL_VERSION_STRING"]			= isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    125 
    126 	const char* const fragShaderSource	=	"${GLSL_VERSION_STRING}\n"
    127 											"#extension GL_EXT_shader_framebuffer_fetch : require\n"
    128 											"layout(location = 0) out mediump vec4 fragColor;\n"
    129 											"\n"
    130 											"void main (void)\n"
    131 											"{\n"
    132 											"	fragColor = gl_LastFragData[0];\n"
    133 											"}\n";
    134 
    135 	glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources()
    136 			<< glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args))
    137 			<< glu::FragmentSource(tcu::StringTemplate(fragShaderSource).specialize(args)));
    138 
    139 	ctx.beginSection("A link error is generated if the built-in fragment outputs of ES 2.0 are used in #version 300 es shaders");
    140 	verifyProgramError(ctx, program, PROGRAM_ERROR_LINK, glu::SHADERTYPE_FRAGMENT);
    141 	ctx.endSection();
    142 }
    143 
    144 void last_frag_data_readonly (NegativeTestContext& ctx)
    145 {
    146 	checkFramebufferFetchSupport(ctx);
    147 
    148 	map<string, string>			args;
    149 	args["GLSL_VERSION_STRING"]			=	getGLSLVersionDeclaration(glu::GLSL_VERSION_100_ES);
    150 
    151 	const char* const fragShaderSource	=	"${GLSL_VERSION_STRING}\n"
    152 											"#extension GL_EXT_shader_framebuffer_fetch : require\n"
    153 											"\n"
    154 											"void main (void)\n"
    155 											"{\n"
    156 											"	gl_LastFragData[0] = vec4(1.0);\n"
    157 											"	gl_FragColor = gl_LastFragData[0];\n"
    158 											"}\n";
    159 
    160 	glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources()
    161 			<< glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args))
    162 			<< glu::FragmentSource(tcu::StringTemplate(fragShaderSource).specialize(args)));
    163 
    164 	ctx.beginSection("A compile-time or link error is generated if the built-in fragment outputs of ES 2.0 are written to.");
    165 	verifyProgramError(ctx, program, PROGRAM_ERROR_COMPILE_OR_LINK, glu::SHADERTYPE_FRAGMENT);
    166 	ctx.endSection();
    167 }
    168 
    169 void invalid_inout_version (NegativeTestContext& ctx)
    170 {
    171 	checkFramebufferFetchSupport(ctx);
    172 
    173 	map<string, string>			args;
    174 	args["GLSL_VERSION_STRING"]			=	getGLSLVersionDeclaration(glu::GLSL_VERSION_100_ES);
    175 
    176 	const char* const fragShaderSource	=	"${GLSL_VERSION_STRING}\n"
    177 											"#extension GL_EXT_shader_framebuffer_fetch : require\n"
    178 											"inout highp vec4 fragColor;\n"
    179 											"\n"
    180 											"void main (void)\n"
    181 											"{\n"
    182 											"	highp float product = dot(vec3(0.5), fragColor.rgb);\n"
    183 											"	gl_FragColor = vec4(product);\n"
    184 											"}\n";
    185 
    186 	glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources()
    187 			<< glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args))
    188 			<< glu::FragmentSource(tcu::StringTemplate(fragShaderSource).specialize(args)));
    189 
    190 	ctx.beginSection("A compile-time or link error is generated if user-defined inout arrays are used in earlier versions of GLSL before ES 3.0");
    191 	verifyProgramError(ctx, program, PROGRAM_ERROR_COMPILE_OR_LINK, glu::SHADERTYPE_FRAGMENT);
    192 	ctx.endSection();
    193 }
    194 
    195 void invalid_redeclaration_inout (NegativeTestContext& ctx)
    196 {
    197 	checkFramebufferFetchSupport(ctx);
    198 
    199 	const bool					isES32	= glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
    200 	map<string, string>			args;
    201 	args["GLSL_VERSION_STRING"]			= isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    202 
    203 	const char* const fragShaderSource	=	"${GLSL_VERSION_STRING}\n"
    204 											"#extension GL_EXT_shader_framebuffer_fetch : require\n"
    205 											"layout(location = 0) out mediump vec4 fragColor;\n"
    206 											"inout highp float gl_FragDepth;\n"
    207 											"\n"
    208 											"void main (void)\n"
    209 											"{\n"
    210 											"	gl_FragDepth += 0.5f;\n"
    211 											"	fragColor = vec4(1.0f);\n"
    212 											"}\n";
    213 
    214 	glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources()
    215 			<< glu::VertexSource(tcu::StringTemplate(vertexShaderSource).specialize(args))
    216 			<< glu::FragmentSource(tcu::StringTemplate(fragShaderSource).specialize(args)));
    217 
    218 	ctx.beginSection("A compile-time or link error is generated if re-declaring an existing fragment output such as gl_FragDepth as inout");
    219 	verifyProgramError(ctx, program, PROGRAM_ERROR_COMPILE_OR_LINK, glu::SHADERTYPE_FRAGMENT);
    220 	ctx.endSection();
    221 }
    222 
    223 void invalid_vertex_inout (NegativeTestContext& ctx)
    224 {
    225 	checkFramebufferFetchSupport(ctx);
    226 
    227 	const bool					isES32	= glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
    228 	map<string, string>			args;
    229 	args["GLSL_VERSION_STRING"]			= isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
    230 
    231 	const char* const vertShaderSource	=	"${GLSL_VERSION_STRING}\n"
    232 											"#extension GL_EXT_shader_framebuffer_fetch : require\n"
    233 											"inout mediump vec4 v_color;\n"
    234 											"\n"
    235 											"void main (void)\n"
    236 											"{\n"
    237 											"}\n";
    238 
    239 	glu::ShaderProgram program(ctx.getRenderContext(), glu::ProgramSources()
    240 			<< glu::VertexSource(tcu::StringTemplate(vertShaderSource).specialize(args))
    241 			<< glu::FragmentSource(tcu::StringTemplate(fragmentShaderSource).specialize(args)));
    242 
    243 	ctx.beginSection("A compile-time error or link error is generated if inout variables are declared in the vertex shader\n");
    244 	verifyProgramError(ctx, program, PROGRAM_ERROR_COMPILE_OR_LINK, glu::SHADERTYPE_VERTEX);
    245 	ctx.endSection();
    246 }
    247 
    248 } // anonymous
    249 
    250 std::vector<FunctionContainer> getNegativeShaderFramebufferFetchTestFunctions (void)
    251 {
    252 	const FunctionContainer funcs[] =
    253 	{
    254 		{ last_frag_data_not_defined,		"last_frag_data_not_defined",		"The built-in gl_LastFragData not defined in #version 300 es shaders"				},
    255 		{ last_frag_data_readonly,			"last_frag_data_readonly",			"Invalid write to readonly builtin in gl_LastFragData"								},
    256 		{ invalid_inout_version,			"invalid_inout_version",			"Invalid use of user-defined inout arrays in versions before GLSL #version 300 es."	},
    257 		{ invalid_redeclaration_inout,		"invalid_redeclaration_inout",		"Existing fragment shader built-ins cannot be redeclared as inout arrays"			},
    258 		{ invalid_vertex_inout,				"invalid_vertex_inout",				"User defined inout arrays are not allowed in the vertex shader"					},
    259 	};
    260 
    261 	return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
    262 }
    263 
    264 } // NegativeTestShared
    265 } // Functional
    266 } // gles31
    267 } // deqp
    268