/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.1 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.
 *
 *//*!
 * \file
 * \brief Negative Shader Directive Tests
 *//*--------------------------------------------------------------------*/

#include "es31fNegativeShaderDirectiveTests.hpp"

#include "gluShaderProgram.hpp"

namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace NegativeTestShared
{
namespace
{

enum ExpectResult
{
	EXPECT_RESULT_PASS = 0,
	EXPECT_RESULT_FAIL,

	EXPECT_RESULT_LAST
};

void verifyProgram(NegativeTestContext& ctx, glu::ProgramSources sources, ExpectResult expect)
{
	DE_ASSERT(expect >= EXPECT_RESULT_PASS && expect < EXPECT_RESULT_LAST);

	tcu::TestLog&				log			= ctx.getLog();
	const glu::ShaderProgram	program		(ctx.getRenderContext(), sources);
	bool						testFailed	= false;
	std::string					message;

	log << program;

	if (expect == EXPECT_RESULT_PASS)
	{
		testFailed = !program.getProgramInfo().linkOk;
		message = "Program did not link.";
	}
	else
	{
		testFailed = program.getProgramInfo().linkOk;
		message = "Program was not expected to link.";
	}

	if (testFailed)
	{
		log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
		ctx.fail(message);
	}
}

void verifyShader(NegativeTestContext& ctx, glu::ShaderType shaderType, std::string shaderSource, ExpectResult expect)
{
	DE_ASSERT(expect >= EXPECT_RESULT_PASS && expect < EXPECT_RESULT_LAST);

	tcu::TestLog&		log			= ctx.getLog();
	bool				testFailed	= false;
	const char* const	source		= shaderSource.c_str();
	const int			length		= (int) shaderSource.size();
	glu::Shader			shader		(ctx.getRenderContext(), shaderType);
	std::string			message;

	shader.setSources(1, &source, &length);
	shader.compile();

	log << shader;

	if (expect == EXPECT_RESULT_PASS)
	{
		testFailed = !shader.getCompileStatus();
		message = "Shader did not compile.";
	}
	else
	{
		testFailed = shader.getCompileStatus();
		message = "Shader was not expected to compile.";
	}

	if (testFailed)
	{
		log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
		ctx.fail(message);
	}
}

void primitive_bounding_box (NegativeTestContext& ctx)
{
	if (ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_CONTROL))
	{
		ctx.beginSection("GL_EXT_primitive_bounding_box features require enabling the extension in 310 es shaders.");
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"void main()\n"
					"{\n"
					"	gl_BoundingBoxEXT[0] = vec4(0.0, 0.0, 0.0, 0.0);\n"
					"	gl_BoundingBoxEXT[1] = vec4(1.0, 1.0, 1.0, 1.0);\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_TESSELLATION_CONTROL, source.str(), EXPECT_RESULT_FAIL);
		ctx.endSection();
	}

	if (contextSupports(ctx.getRenderContext().getType() , glu::ApiType::es(3, 2)))
	{
		ctx.beginSection("gl_BoundingBox does not require the OES/EXT suffix in a 320 es shader.");
		const std::string source =	"#version 320 es\n"
									"layout(vertices = 3) out;\n"
									"void main()\n"
									"{\n"
									"	gl_BoundingBox[0] = vec4(0.0, 0.0, 0.0, 0.0);\n"
									"	gl_BoundingBox[1] = vec4(0.0, 0.0, 0.0, 0.0);\n"
									"}\n";
		verifyShader(ctx, glu::SHADERTYPE_TESSELLATION_CONTROL, source, EXPECT_RESULT_PASS);
		ctx.endSection();
	}
}

void blend_equation_advanced (NegativeTestContext& ctx)
{
	static const char* const s_qualifiers[] =
	{
		"blend_support_multiply",
		"blend_support_screen",
		"blend_support_overlay",
		"blend_support_darken",
		"blend_support_lighten",
		"blend_support_colordodge",
		"blend_support_colorburn",
		"blend_support_hardlight",
		"blend_support_softlight",
		"blend_support_difference",
		"blend_support_exclusion",
		"blend_support_hsl_hue",
		"blend_support_hsl_saturation",
		"blend_support_hsl_color",
		"blend_support_hsl_luminosity",
	};

	ctx.beginSection("GL_KHR_blend_equation_advanced features require enabling the extension in 310 es shaders.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_qualifiers); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"layout(" << s_qualifiers[ndx] << ") out;\n"
					"void main()\n"
					"{\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
}

void sample_variables (NegativeTestContext& ctx)
{
	TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(ctx.getRenderContext().getType() , glu::ApiType::es(3, 2)), "Test requires a context version 3.2 or higher.");

	static const char* const s_tests[] =
	{
		"int sampleId = gl_SampleID;",
		"vec2 samplePos = gl_SamplePosition;",
		"int sampleMaskIn0 = gl_SampleMaskIn[0];",
		"int sampleMask0 = gl_SampleMask[0];",
		"int numSamples = gl_NumSamples;",
	};

	ctx.beginSection("GL_OES_sample_variables features require enabling the extension in 310 es shaders.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_tests); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"precision mediump float;\n"
					"void main()\n"
					"{\n"
					"	" << s_tests[ndx] << "\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
}

void shader_image_atomic (NegativeTestContext& ctx)
{
	static const char* const s_tests[] =
	{
		"imageAtomicAdd(u_image, ivec2(1, 1), 1u);",
		"imageAtomicMin(u_image, ivec2(1, 1), 1u);",
		"imageAtomicMax(u_image, ivec2(1, 1), 1u);",
		"imageAtomicAnd(u_image, ivec2(1, 1), 1u);",
		"imageAtomicOr(u_image, ivec2(1, 1), 1u);",
		"imageAtomicXor(u_image, ivec2(1, 1), 1u);",
		"imageAtomicExchange(u_image, ivec2(1, 1), 1u);",
		"imageAtomicCompSwap(u_image, ivec2(1, 1), 1u, 1u);",
	};

	ctx.beginSection("GL_OES_shader_image_atomic features require enabling the extension in 310 es shaders.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_tests); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"layout(binding=0, r32ui) coherent uniform highp uimage2D u_image;\n"
					"precision mediump float;\n"
					"void main()\n"
					"{\n"
					"	" << s_tests[ndx] << "\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
}

void shader_multisample_interpolation (NegativeTestContext& ctx)
{
	static const char* const s_sampleTests[] =
	{
		"sample in highp float v_var;",
		"sample out highp float v_var;"
	};

	static const char* const s_interpolateAtTests[] =
	{
		"interpolateAtCentroid(interpolant);",
		"interpolateAtSample(interpolant, 1);",
		"interpolateAtOffset(interpolant, vec2(1.0, 0.0));"
	};

	ctx.beginSection("GL_OES_shader_multisample_interpolation features require enabling the extension in 310 es shaders.");
	ctx.beginSection("Test sample in/out qualifiers.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_sampleTests); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"	" << s_sampleTests[ndx] << "\n"
					"precision mediump float;\n"
					"void main()\n"
					"{\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();

	ctx.beginSection("Test interpolateAt* functions.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_sampleTests); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"in mediump float interpolant;\n"
					"precision mediump float;\n"
					"void main()\n"
					"{\n"
					"	" << s_interpolateAtTests[ndx] << "\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
	ctx.endSection();
}

void texture_storage_multisample_2d_array (NegativeTestContext& ctx)
{
	static const char* const s_samplerTypeTests[] =
	{
		"uniform mediump sampler2DMSArray u_sampler;",
		"uniform mediump isampler2DMSArray u_sampler;",
		"uniform mediump usampler2DMSArray u_sampler;",
	};

	ctx.beginSection("GL_OES_texture_storage_multisample_2d_array features require enabling the extension in 310 es shaders.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_samplerTypeTests); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"	" << s_samplerTypeTests[ndx] << "\n"
					"precision mediump float;\n"
					"void main()\n"
					"{\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
}

void geometry_shader (NegativeTestContext& ctx)
{
	if (ctx.isShaderSupported(glu::SHADERTYPE_GEOMETRY))
	{
		const std::string	simpleVtxFrag	=	"#version 310 es\n"
												"void main()\n"
												"{\n"
												"}\n";
		const std::string	geometry		=	"#version 310 es\n"
												"layout(points, invocations = 1) in;\n"
												"layout(points, max_vertices = 3) out;\n"
												"precision mediump float;\n"
												"void main()\n"
												"{\n"
												"	EmitVertex();\n"
												"	EndPrimitive();\n"
												"}\n";
		ctx.beginSection("GL_EXT_geometry_shader features require enabling the extension in 310 es shaders.");
		verifyProgram(ctx, glu::ProgramSources() << glu::VertexSource(simpleVtxFrag) << glu::GeometrySource(geometry) << glu::FragmentSource(simpleVtxFrag), EXPECT_RESULT_FAIL);
		ctx.endSection();
	}
}

void gpu_shader_5 (NegativeTestContext& ctx)
{
	ctx.beginSection("GL_EXT_gpu_shader5 features require enabling the extension in 310 es shaders.");
	ctx.beginSection("Testing the precise qualifier.");
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"void main()\n"
					"{\n"
					"	int low = 0;\n"
					"	int high = 10;\n"
					"	precise int middle = low + ((high - low) / 2);\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();

	ctx.beginSection("Testing fused multiply-add.");
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"in mediump float v_var;"
					"void main()\n"
					"{\n"
					"	float fmaResult = fma(v_var, v_var, v_var);"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();

	ctx.beginSection("Testing textureGatherOffsets.");
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"uniform mediump sampler2D u_tex;\n"
					"void main()\n"
					"{\n"
					"	highp vec2 coords = vec2(0.0, 1.0);\n"
					"	const ivec2 offsets[4] = ivec2[](ivec2(0,0), ivec2(1, 0), ivec2(0, 1), ivec2(1, 1));\n"
					"	textureGatherOffsets(u_tex, coords, offsets);\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();

	ctx.endSection();
}

void shader_io_blocks (NegativeTestContext& ctx)
{
	ctx.beginSection("GL_EXT_shader_io_blocks features require enabling the extension in 310 es shaders.");
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"in Data\n"
					"{\n"
					"	mediump vec3 a;\n"
					"} data;\n"
					"void main()\n"
					"{\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
}

void tessellation_shader (NegativeTestContext& ctx)
{
	if (ctx.isShaderSupported(glu::SHADERTYPE_TESSELLATION_CONTROL))
	{
		const std::string	simpleVtxFrag	=	"#version 310 es\n"
												"void main()\n"
												"{\n"
												"}\n";
		const std::string	tessControl		=	"#version 310 es\n"
												"layout(vertices = 3) out;\n"
												"void main()\n"
												"{\n"
												"}\n";
		const std::string	tessEvaluation	=	"#version 310 es\n"
												"layout(triangles, equal_spacing, cw) in;\n"
												"void main()\n"
												"{\n"
												"}\n";
		ctx.beginSection("GL_EXT_tessellation_shader features require enabling the extension in 310 es shaders.");
		glu::ProgramSources sources;
		sources << glu::VertexSource(simpleVtxFrag)
				<< glu::TessellationControlSource(tessControl)
				<< glu::TessellationEvaluationSource(tessEvaluation)
				<< glu::FragmentSource(simpleVtxFrag);
		verifyProgram(ctx, sources, EXPECT_RESULT_FAIL);
		ctx.endSection();
	}
}

void texture_buffer (NegativeTestContext& ctx)
{
	static const char* const s_samplerBufferTypes[] =
	{
		"uniform mediump samplerBuffer",
	    "uniform mediump isamplerBuffer",
	    "uniform mediump usamplerBuffer",
	    "layout(rgba32f) uniform mediump writeonly imageBuffer",
	    "layout(rgba32i) uniform mediump writeonly iimageBuffer",
	    "layout(rgba32ui) uniform mediump writeonly uimageBuffer"
	};

	ctx.beginSection("GL_EXT_texture_buffer features require enabling the extension in 310 es shaders.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_samplerBufferTypes); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"" << s_samplerBufferTypes[ndx] << " u_buffer;\n"
					"void main()\n"
					"{\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
}


void texture_cube_map_array (NegativeTestContext& ctx)
{
	static const char* const s_samplerCubeArrayTypes[] =
	{
	    "uniform mediump samplerCubeArray",
	    "uniform mediump isamplerCubeArray",
	    "uniform mediump usamplerCubeArray",
	    "uniform mediump samplerCubeArrayShadow",
	    "layout(rgba32f) uniform mediump writeonly imageCubeArray",
	    "layout(rgba32i) uniform mediump writeonly iimageCubeArray",
	    "layout(rgba32ui) uniform mediump writeonly uimageCubeArray"
	};

	ctx.beginSection("GL_EXT_texture_cube_map_array features require enabling the extension in 310 es shaders.");
	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_samplerCubeArrayTypes); ++ndx)
	{
		std::ostringstream source;
		source <<	"#version 310 es\n"
					"" << s_samplerCubeArrayTypes[ndx] << " u_cube;\n"
					"void main()\n"
					"{\n"
					"}\n";
		verifyShader(ctx, glu::SHADERTYPE_FRAGMENT, source.str(), EXPECT_RESULT_FAIL);
	}
	ctx.endSection();
}

} // anonymous

std::vector<FunctionContainer> getNegativeShaderDirectiveTestFunctions (void)
{
	const FunctionContainer funcs[] =
	{
		{primitive_bounding_box,				"primitive_bounding_box",				"GL_EXT_primitive_bounding_box required in 310 es shaders to use AEP features. Version 320 es shaders do not require suffixes."	},
		{blend_equation_advanced,				"blend_equation_advanced",				"GL_KHR_blend_equation_advanced is required in 310 es shaders to use AEP features"												},
		{sample_variables,						"sample_variables",						"GL_OES_sample_variables is required in 310 es shaders to use AEP features"														},
		{shader_image_atomic,					"shader_image_atomic",					"GL_OES_shader_image_atomic is required in 310 es shaders to use AEP features"													},
		{shader_multisample_interpolation,		"shader_multisample_interpolation",		"GL_OES_shader_multisample_interpolation is required in 310 es shaders to use AEP features"										},
		{texture_storage_multisample_2d_array,	"texture_storage_multisample_2d_array",	"GL_OES_texture_storage_multisample_2d_array is required in 310 es shaders to use AEP features"									},
		{geometry_shader,						"geometry_shader",						"GL_EXT_geometry_shader is required in 310 es shaders to use AEP features"														},
		{gpu_shader_5,							"gpu_shader_5",							"GL_EXT_gpu_shader5 is required in 310 es shaders to use AEP features"															},
		{shader_io_blocks,						"shader_io_blocks",						"GL_EXT_shader_io_blocks is required in 310 es shaders to use AEP features"														},
		{tessellation_shader,					"tessellation_shader",					"GL_EXT_tessellation_shader is required in 310 es shaders to use AEP features"													},
		{texture_buffer,						"texture_buffer",						"GL_EXT_texture_buffer is required in 310 es shaders to use AEP features"														},
		{texture_cube_map_array,				"texture_cube_map_array",				"GL_EXT_texture_cube_map_array is required in 310 es shaders to use AEP features"												},
	};

	return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
}

} // NegativeTestShared
} // Functional
} // gles31
} // deqp