1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.1 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2016 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 Precise Tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "es31fNegativePreciseTests.hpp"
25
26 #include "gluShaderProgram.hpp"
27 #include "glwEnums.hpp"
28
29 namespace deqp
30 {
31 namespace gles31
32 {
33 namespace Functional
34 {
35 namespace NegativeTestShared
36 {
37 namespace
38 {
39
40 enum TestPrecise
41 {
42 TEST_PRECISE_AS_VARIABLE_NAME = 0,
43 TEST_PRECISE_AS_FUNCTION_NAME,
44 TEST_PRECISE_AS_ARGUMENT_NAME,
45 TEST_PRECISE_AS_MACRO_NAME,
46 TEST_PRECISE_MACRO_AND_VARIABLE,
47 TEST_PRECISE_MACRO_AND_FUNCTION,
48 TEST_PRECISE_MACRO_AND_ARGUMENT,
49
50 TEST_PRECISE_LAST
51 };
52
53 static const glu::ShaderType s_shaderTypes[] = {glu::SHADERTYPE_VERTEX,
54 glu::SHADERTYPE_FRAGMENT,
55 glu::SHADERTYPE_GEOMETRY,
56 glu::SHADERTYPE_COMPUTE,
57 glu::SHADERTYPE_TESSELLATION_CONTROL,
58 glu::SHADERTYPE_TESSELLATION_EVALUATION};
59
generateShaderSource(NegativeTestContext & ctx,glu::ShaderType shaderType,TestPrecise test)60 std::string generateShaderSource(NegativeTestContext &ctx, glu::ShaderType shaderType, TestPrecise test)
61 {
62 const bool supportsES32 = contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
63 const glu::GLSLVersion version = supportsES32 ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES;
64 std::ostringstream source;
65
66 source << glu::getGLSLVersionDeclaration(version) << "\n"
67 << (supportsES32 ? "" : "#extension GL_EXT_gpu_shader5 : enable\n");
68
69 switch (test)
70 {
71 case TEST_PRECISE_AS_MACRO_NAME:
72 source << "#define precise 0\n";
73 break;
74
75 case TEST_PRECISE_MACRO_AND_VARIABLE:
76 case TEST_PRECISE_MACRO_AND_FUNCTION:
77 case TEST_PRECISE_MACRO_AND_ARGUMENT:
78 source << "#define precise aName\n";
79 break;
80 default:
81 break;
82 }
83
84 switch (shaderType)
85 {
86 case glu::SHADERTYPE_GEOMETRY:
87 source << (supportsES32 ? "" : "#extension GL_EXT_geometry_shader : enable\n")
88 << "layout(max_vertices = 5) out;\n";
89 break;
90
91 case glu::SHADERTYPE_TESSELLATION_CONTROL:
92 source << (supportsES32 ? "" : "#extension GL_EXT_tessellation_shader : enable\n")
93 << "layout(vertices = 3) out;\n";
94 break;
95
96 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
97 source << (supportsES32 ? "" : "#extension GL_EXT_tessellation_shader : enable\n")
98 << "layout(triangles, equal_spacing, cw) in;\n";
99 break;
100
101 default:
102 break;
103 }
104
105 switch (test)
106 {
107 case TEST_PRECISE_AS_FUNCTION_NAME:
108 case TEST_PRECISE_MACRO_AND_FUNCTION:
109 source << "\n"
110 << "void precise()\n"
111 << "{\n"
112 << "}\n";
113 break;
114
115 case TEST_PRECISE_AS_ARGUMENT_NAME:
116 case TEST_PRECISE_MACRO_AND_ARGUMENT:
117 source << "\n"
118 << "void example(int precise)\n"
119 << "{\n"
120 << "}\n";
121 break;
122
123 default:
124 break;
125 }
126
127 source << "void main()\n"
128 << "{\n";
129
130 switch (test)
131 {
132 case TEST_PRECISE_AS_VARIABLE_NAME:
133 case TEST_PRECISE_MACRO_AND_VARIABLE:
134 source << " int precise = 1;\n";
135 break;
136 case TEST_PRECISE_AS_MACRO_NAME:
137 source << " int number = precise;\n";
138 break;
139 default:
140 break;
141 }
142
143 source << "}\n";
144
145 return source.str();
146 }
147
generateAndVerifyShader(NegativeTestContext & ctx,glu::ShaderType shaderType,TestPrecise test)148 void generateAndVerifyShader(NegativeTestContext &ctx, glu::ShaderType shaderType, TestPrecise test)
149 {
150 glu::Shader shader(ctx.getRenderContext(), shaderType);
151 std::string shaderSource = generateShaderSource(ctx, shaderType, test);
152 const char *const source = shaderSource.c_str();
153 const int length = (int)shaderSource.size();
154
155 shader.setSources(1, &source, &length);
156 shader.compile();
157
158 ctx.getLog() << shader;
159
160 if (shader.getCompileStatus())
161 ctx.fail("Shader was not expected to compile.");
162 }
163
checkSupport(NegativeTestContext & ctx)164 static bool checkSupport(NegativeTestContext &ctx)
165 {
166 return ctx.isExtensionSupported("GL_EXT_gpu_shader5") ||
167 contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
168 contextSupports(ctx.getRenderContext().getType(), glu::ApiType::core(4, 5));
169 }
170
precise_as_variable_name(NegativeTestContext & ctx)171 void precise_as_variable_name(NegativeTestContext &ctx)
172 {
173 TCU_CHECK_AND_THROW(
174 NotSupportedError, checkSupport(ctx),
175 "This test requires support for the extension GL_EXT_gpu_shader5 or context version 3.2 or higher.");
176
177 ctx.beginSection("Test that precise cannot be used as a variable name.");
178 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_shaderTypes); ++ndx)
179 {
180 if (ctx.isShaderSupported(s_shaderTypes[ndx]))
181 generateAndVerifyShader(ctx, s_shaderTypes[ndx], TEST_PRECISE_AS_VARIABLE_NAME);
182 }
183 ctx.endSection();
184 }
185
precise_as_function_name(NegativeTestContext & ctx)186 void precise_as_function_name(NegativeTestContext &ctx)
187 {
188 TCU_CHECK_AND_THROW(
189 NotSupportedError, checkSupport(ctx),
190 "This test requires support for the extension GL_EXT_gpu_shader5 or context version 3.2 or higher.");
191
192 ctx.beginSection("Test that precise cannot be used as a function name.");
193 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_shaderTypes); ++ndx)
194 {
195 if (ctx.isShaderSupported(s_shaderTypes[ndx]))
196 generateAndVerifyShader(ctx, s_shaderTypes[ndx], TEST_PRECISE_AS_FUNCTION_NAME);
197 }
198 ctx.endSection();
199 }
200
precise_as_function_argument(NegativeTestContext & ctx)201 void precise_as_function_argument(NegativeTestContext &ctx)
202 {
203 TCU_CHECK_AND_THROW(
204 NotSupportedError, checkSupport(ctx),
205 "This test requires support for the extension GL_EXT_gpu_shader5 or context version 3.2 or higher.");
206
207 ctx.beginSection("Test that precise cannot be used as a argument name.");
208 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_shaderTypes); ++ndx)
209 {
210 if (ctx.isShaderSupported(s_shaderTypes[ndx]))
211 generateAndVerifyShader(ctx, s_shaderTypes[ndx], TEST_PRECISE_AS_ARGUMENT_NAME);
212 }
213 ctx.endSection();
214 }
215
216 } // namespace
217
getNegativePreciseTestFunctions(void)218 std::vector<FunctionContainer> getNegativePreciseTestFunctions(void)
219 {
220 const FunctionContainer funcs[] = {
221 {precise_as_variable_name, "precise_as_variable_name", "Test precise keyword as variable name."},
222 {precise_as_function_name, "precise_as_function_name", "Test precise keyword as function name."},
223 {precise_as_function_argument, "precise_as_function_argument", "Test precise keyword as argument name."},
224 };
225
226 return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
227 }
228
229 } // namespace NegativeTestShared
230 } // namespace Functional
231 } // namespace gles31
232 } // namespace deqp
233