Merge "Report Android extension pack tests as not supported"
[platform/upstream/VK-GL-CTS.git] / modules / gles31 / functional / es31fNegativeComputeTests.cpp
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 Compute tests.
22  *//*--------------------------------------------------------------------*/
23
24 #include "es31fNegativeComputeTests.hpp"
25 #include "gluContextInfo.hpp"
26 #include "gluShaderProgram.hpp"
27 #include "glwDefs.hpp"
28 #include "glwEnums.hpp"
29 #include "tcuStringTemplate.hpp"
30
31 namespace deqp
32 {
33
34 using std::string;
35 using std::map;
36
37 namespace gles31
38 {
39 namespace Functional
40 {
41 namespace NegativeTestShared
42 {
43 namespace
44 {
45
46 using tcu::TestLog;
47 using namespace glw;
48
49 static const char* const vertexShaderSource                     =       "${GLSL_VERSION_STRING}\n"
50                                                                                                                 "\n"
51                                                                                                                 "void main (void)\n"
52                                                                                                                 "{\n"
53                                                                                                                 "       gl_Position = vec4(0.0);\n"
54                                                                                                                 "}\n";
55
56 static const char* const fragmentShaderSource           =       "${GLSL_VERSION_STRING}\n"
57                                                                                                                 "precision mediump float;\n"
58                                                                                                                 "layout(location = 0) out mediump vec4 fragColor;\n"
59                                                                                                                 "\n"
60                                                                                                                 "void main (void)\n"
61                                                                                                                 "{\n"
62                                                                                                                 "       fragColor = vec4(1.0);\n"
63                                                                                                                 "}\n";
64
65 static const char* const computeShaderSource            =       "${GLSL_VERSION_STRING}\n"
66                                                                                                                 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
67                                                                                                                 "void main (void)\n"
68                                                                                                                 "{\n"
69                                                                                                                 "}\n";
70
71 static const char* const invalidComputeShaderSource     =       "${GLSL_VERSION_STRING}\n"
72                                                                                                                 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
73                                                                                                                 "void main (void)\n"
74                                                                                                                 "{\n"
75                                                                                                                 "       highp uint var = -1;\n" // error
76                                                                                                                 "}\n";
77
78 int getResourceLimit (NegativeTestContext& ctx, GLenum resource)
79 {
80         int limit = 0;
81         ctx.glGetIntegerv(resource, &limit);
82
83         return limit;
84 }
85
86 void verifyLinkError (NegativeTestContext& ctx, const glu::ShaderProgram& program)
87 {
88         bool testFailed = false;
89
90         tcu::TestLog& log = ctx.getLog();
91         log << program;
92
93         testFailed = program.getProgramInfo().linkOk;
94
95         if (testFailed)
96         {
97                 const char* const message("Program was not expected to link.");
98                 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
99                 ctx.fail(message);
100         }
101 }
102
103 void verifyCompileError (NegativeTestContext& ctx, const glu::ShaderProgram& program, glu::ShaderType shaderType)
104 {
105         bool testFailed = false;
106
107         tcu::TestLog& log = ctx.getLog();
108         log << program;
109
110         testFailed = program.getShaderInfo(shaderType).compileOk;
111
112         if (testFailed)
113         {
114                 const char* const message("Program was not expected to compile.");
115                 log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
116                 ctx.fail(message);
117         }
118 }
119
120 string generateComputeShader (NegativeTestContext& ctx, const string& shaderDeclarations, const string& shaderBody)
121 {
122         const bool                      isES32                  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
123         const char* const       shaderVersion   = isES32
124                                                                                 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES)
125                                                                                 : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
126
127         std::ostringstream compShaderSource;
128
129         compShaderSource        <<      shaderVersion << "\n"
130                                                 <<      "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
131                                                 <<      shaderDeclarations << "\n"
132                                                 <<      "void main (void)\n"
133                                                 <<      "{\n"
134                                                 <<      shaderBody
135                                                 <<      "}\n";
136
137         return compShaderSource.str();
138 }
139
140 string genBuiltInSource (glu::ShaderType shaderType)
141 {
142         std::ostringstream              source;
143         source << "${GLSL_VERSION_STRING}\n";
144
145         switch (shaderType)
146         {
147                 case glu::SHADERTYPE_VERTEX:
148                 case glu::SHADERTYPE_FRAGMENT:
149                         break;
150
151                 case glu::SHADERTYPE_COMPUTE:
152                         source << "layout (local_size_x = 1) in;\n";
153                         break;
154
155                 case glu::SHADERTYPE_GEOMETRY:
156                         source << "layout(points) in;\n"
157                                    << "layout(line_strip, max_vertices = 3) out;\n";
158                         break;
159
160                 case glu::SHADERTYPE_TESSELLATION_CONTROL:
161                         source << "${GLSL_TESS_EXTENSION_STRING}\n"
162                                    << "layout(vertices = 10) out;\n";
163                         break;
164
165                 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
166                         source << "${GLSL_TESS_EXTENSION_STRING}\n"
167                                    << "layout(triangles) in;\n";
168                         break;
169
170                 default:
171                         DE_FATAL("Unknown shader type");
172                         break;
173         }
174
175         source  << "\n"
176                         << "void main(void)\n"
177                         << "{\n"
178                         << "${COMPUTE_BUILT_IN_CONSTANTS_STRING}"
179                         << "}\n";
180
181         return source.str();
182 }
183
184 void exceed_uniform_block_limit (NegativeTestContext& ctx)
185 {
186         std::ostringstream shaderDecl;
187         std::ostringstream shaderBody;
188
189         shaderDecl      << "layout(std140, binding = 0) uniform Block\n"
190                                 << "{\n"
191                                 << "    highp vec4 val;\n"
192                                 << "} block[" << getResourceLimit(ctx, GL_MAX_COMPUTE_UNIFORM_BLOCKS) + 1 << "];\n";
193
194         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
195                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
196
197         ctx.beginSection("Link error is generated if a compute shader exceeds GL_MAX_COMPUTE_UNIFORM_BLOCKS.");
198         verifyLinkError(ctx, program);
199         ctx.endSection();
200 }
201
202 void exceed_shader_storage_block_limit (NegativeTestContext& ctx)
203 {
204         std::ostringstream shaderDecl;
205         std::ostringstream shaderBody;
206
207         shaderDecl      << "layout(std140, binding = 0) buffer Block\n"
208                                 << "{\n"
209                                 << "    highp vec4 val;\n"
210                                 << "} block[" << getResourceLimit(ctx, GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS) + 1 << "];\n";
211
212         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
213                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
214
215         ctx.beginSection("Link error is generated if compute shader exceeds GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS.");
216         verifyLinkError(ctx, program);
217         ctx.endSection();
218 }
219
220 void exceed_texture_image_units_limit (NegativeTestContext& ctx)
221 {
222         const int                       limit                   = getResourceLimit(ctx, GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS) + 1;
223         std::ostringstream      shaderDecl;
224         std::ostringstream      shaderBody;
225
226         shaderDecl      << "layout(binding = 0) "
227                                 << "uniform highp sampler2D u_sampler[" << limit + 1 << "];\n"
228                                 << "\n"
229                                 << "layout(binding = 0) buffer Output {\n"
230                                 << "    vec4 values[ " << limit + 1 << " ];\n"
231                                 << "} sb_out;\n";
232
233         for (int i = 0; i < limit + 1; ++i)
234                 shaderBody      << "   sb_out.values[" << i << "] = texture(u_sampler[" << i << "], vec2(1.0f));\n";
235
236         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
237                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
238
239         tcu::TestLog& log = ctx.getLog();
240         log << tcu::TestLog::Message << "Possible link error is generated if compute shader exceeds GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS." << tcu::TestLog::EndMessage;
241         log << program;
242
243         if (program.getProgramInfo().linkOk)
244         {
245                 log << tcu::TestLog::Message << "Quality Warning: program was not expected to link." << tcu::TestLog::EndMessage;
246                 ctx.glUseProgram(program.getProgram());
247                 ctx.expectError(GL_NO_ERROR);
248
249                 ctx.beginSection("GL_INVALID_OPERATION error is generated if the sum of the number of active samplers for each active program exceeds the maximum number of texture image units allowed");
250                 ctx.glDispatchCompute(1, 1, 1);
251                 ctx.expectError(GL_INVALID_VALUE);
252                 ctx.endSection();
253         }
254 }
255
256 void exceed_image_uniforms_limit (NegativeTestContext& ctx)
257 {
258         const int                       limit = getResourceLimit(ctx, GL_MAX_COMPUTE_IMAGE_UNIFORMS);
259         std::ostringstream      shaderDecl;
260         std::ostringstream      shaderBody;
261
262         shaderDecl      << "layout(rgba8, binding = 0) "
263                                 << "uniform readonly highp image2D u_image[" << limit + 1 << "];\n"
264                                 << "\n"
265                                 << "layout(binding = 0) buffer Output {\n"
266                                 << "    float values[" << limit + 1 << "];\n"
267                                 << "} sb_out;\n";
268
269         for (int i = 0; i < limit + 1; ++i)
270                 shaderBody      << "    sb_out.values[" << i << "]" << "  = imageLoad(u_image[" << i << "], ivec2(gl_GlobalInvocationID.xy)).x;\n";
271
272         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
273                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
274
275         ctx.beginSection("Link error is generated if compute shader exceeds GL_MAX_COMPUTE_IMAGE_UNIFORMS.");
276         verifyLinkError(ctx, program);
277         ctx.endSection();
278 }
279
280 void exceed_shared_memory_size_limit (NegativeTestContext& ctx)
281 {
282         const int                       limit                           = getResourceLimit(ctx, GL_MAX_COMPUTE_SHARED_MEMORY_SIZE);
283         const long                      numberOfElements        = limit / sizeof(GLuint);
284         std::ostringstream      shaderDecl;
285         std::ostringstream      shaderBody;
286
287         shaderDecl      << "shared uint values[" << numberOfElements + 1 << "];\n"
288                                 << "\n"
289                                 << "layout(binding = 0) buffer Output {\n"
290                                 << "    uint values;\n"
291                                 << "} sb_out;\n";
292
293         shaderBody      << "    sb_out.values = values[" << numberOfElements << "];\n";
294
295         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
296                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
297
298         ctx.beginSection("Link error is generated if compute shader exceeds GL_MAX_COMPUTE_SHARED_MEMORY_SIZE.");
299         verifyLinkError(ctx, program);
300         ctx.endSection();
301 }
302
303 void exceed_uniform_components_limit (NegativeTestContext& ctx)
304 {
305         const int                       limit = getResourceLimit(ctx, GL_MAX_COMPUTE_UNIFORM_COMPONENTS);
306         std::ostringstream      shaderDecl;
307         std::ostringstream      shaderBody;
308
309         shaderDecl      << "uniform highp uint u_value[" << limit + 1 << "];\n"
310                                 << "\n"
311                                 << "layout(binding = 0) buffer Output {\n"
312                                 << "    uint values[2];\n"
313                                 << "} sb_out;\n";
314
315         shaderBody << "    sb_out.values[0] = u_value[" << limit << "];\n";
316         shaderBody << "    sb_out.values[1] = u_value[0];\n";
317
318         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
319                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
320
321         ctx.beginSection("Link error is generated if compute shader exceeds GL_MAX_COMPUTE_UNIFORM_COMPONENTS.");
322         verifyLinkError(ctx, program);
323         ctx.endSection();
324 }
325
326 void exceed_atomic_counter_buffer_limit (NegativeTestContext& ctx)
327 {
328         const int                       limit = getResourceLimit(ctx, GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS);
329         std::ostringstream      shaderDecl;
330         std::ostringstream      shaderBody;
331
332         for (int i = 0; i < limit + 1; ++i)
333         {
334                 shaderDecl      << "layout(binding = " << i << ") "
335                                         << "uniform atomic_uint u_atomic" << i << ";\n";
336
337                 if (i == 0)
338                         shaderBody      << "    uint oldVal = atomicCounterIncrement(u_atomic" << i << ");\n";
339                 else
340                         shaderBody      << "    oldVal = atomicCounterIncrement(u_atomic" << i << ");\n";
341         }
342
343         shaderBody      << "    sb_out.value = oldVal;\n";
344
345         shaderDecl      << "\n"
346                                 << "layout(binding = 0) buffer Output {\n"
347                                 << "    uint value;\n"
348                                 << "} sb_out;\n";
349
350         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
351                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
352
353         ctx.beginSection("Link error is generated if compute shader exceeds GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS.");
354         verifyLinkError(ctx, program);
355         ctx.endSection();
356 }
357
358 void exceed_atomic_counters_limit (NegativeTestContext& ctx)
359 {
360         std::ostringstream      shaderDecl;
361         std::ostringstream      shaderBody;
362
363         shaderDecl      << "layout(binding = 0, offset = 0) uniform atomic_uint u_atomic0;\n"
364                                 << "layout(binding = " << sizeof(GLuint) * getResourceLimit(ctx, GL_MAX_COMPUTE_ATOMIC_COUNTERS) << ", offset = 0) uniform atomic_uint u_atomic1;\n"
365                                 << "\n"
366                                 << "layout(binding = 0) buffer Output {\n"
367                                 << "    uint value;\n"
368                                 << "} sb_out;\n";
369
370         shaderBody      << "    uint oldVal = 0u;\n"
371                                 << "    oldVal = atomicCounterIncrement(u_atomic0);\n"
372                                 << "    oldVal = atomicCounterIncrement(u_atomic1);\n"
373                                 << "    sb_out.value = oldVal;\n";
374
375         glu::ShaderProgram      program(ctx.getRenderContext(), glu::ProgramSources()
376                         << glu::ComputeSource(generateComputeShader(ctx, shaderDecl.str(), shaderBody.str())));
377
378         ctx.beginSection("Link error is generated if compute shader exceeds GL_MAX_COMPUTE_ATOMIC_COUNTERS.");
379         verifyLinkError(ctx, program);
380         ctx.endSection();
381 }
382
383 void program_not_active (NegativeTestContext& ctx)
384 {
385         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
386         map<string, string>                     args;
387         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
388
389         const glu::VertexSource         vertSource(tcu::StringTemplate(vertexShaderSource).specialize(args));
390         const glu::FragmentSource       fragSource(tcu::StringTemplate(fragmentShaderSource).specialize(args));
391
392         glu::ProgramPipeline            pipeline(ctx.getRenderContext());
393
394         glu::ShaderProgram                      vertProgram     (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << vertSource);
395         glu::ShaderProgram                      fragProgram     (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << fragSource);
396
397         tcu::TestLog& log                       = ctx.getLog();
398         log << vertProgram << fragProgram;
399
400         if (!vertProgram.isOk() || !fragProgram.isOk())
401                 TCU_THROW(InternalError, "failed to build program");
402
403         ctx.glBindProgramPipeline(pipeline.getPipeline());
404         ctx.expectError(GL_NO_ERROR);
405
406         ctx.beginSection("Program not set at all");
407         {
408                 ctx.beginSection("GL_INVALID_OPERATION is generated by glDispatchCompute if there is no active program for the compute shader stage.");
409                 ctx.glDispatchCompute(1, 1, 1);
410                 ctx.expectError(GL_INVALID_OPERATION);
411                 ctx.endSection();
412
413                 ctx.beginSection("GL_INVALID_OPERATION is generated by glDispatchComputeIndirect if there is no active program for the compute shader stage.");
414                 GLintptr indirect = 0;
415                 ctx.glDispatchComputeIndirect(indirect);
416                 ctx.expectError(GL_INVALID_OPERATION);
417                 ctx.endSection();
418         }
419         ctx.endSection();
420
421         ctx.beginSection("Program contains graphic pipeline stages");
422         {
423                 ctx.glUseProgramStages(pipeline.getPipeline(), GL_VERTEX_SHADER_BIT, vertProgram.getProgram());
424                 ctx.glUseProgramStages(pipeline.getPipeline(), GL_FRAGMENT_SHADER_BIT, fragProgram.getProgram());
425                 ctx.expectError(GL_NO_ERROR);
426
427                 ctx.beginSection("GL_INVALID_OPERATION is generated by glDispatchCompute if there is no active program for the compute shader stage.");
428                 ctx.glDispatchCompute(1, 1, 1);
429                 ctx.expectError(GL_INVALID_OPERATION);
430                 ctx.endSection();
431
432                 ctx.beginSection("GL_INVALID_OPERATION is generated by glDispatchComputeIndirect if there is no active program for the compute shader stage.");
433                 GLintptr indirect = 0;
434                 ctx.glDispatchComputeIndirect(indirect);
435                 ctx.expectError(GL_INVALID_OPERATION);
436                 ctx.endSection();
437         }
438         ctx.endSection();
439
440         ctx.glBindProgramPipeline(0);
441         ctx.expectError(GL_NO_ERROR);
442 }
443
444 void invalid_program_query (NegativeTestContext& ctx)
445 {
446         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
447         map<string, string>                     args;
448         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
449
450         GLint data[3] = { 0, 0, 0 };
451
452         ctx.beginSection("Compute shader that does not link");
453         {
454                 const glu::ComputeSource        compSource(tcu::StringTemplate(invalidComputeShaderSource).specialize(args));
455                 glu::ShaderProgram                      invalidComputeProgram (ctx.getRenderContext(), glu::ProgramSources() << compSource);
456
457                 tcu::TestLog& log = ctx.getLog();
458                 log << invalidComputeProgram;
459
460                 if (invalidComputeProgram.isOk())
461                         TCU_THROW(InternalError, "program should not of built");
462
463                 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_COMPUTE_WORK_GROUP_SIZE is queried for a program which has not been linked properly.");
464                 ctx.glGetProgramiv(invalidComputeProgram.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, &data[0]);
465                 ctx.expectError(GL_INVALID_OPERATION);
466                 ctx.endSection();
467
468                 ctx.glUseProgram(0);
469         }
470         ctx.endSection();
471
472         ctx.beginSection("Compute shader not present");
473         {
474                 const glu::VertexSource         vertSource(tcu::StringTemplate(vertexShaderSource).specialize(args));
475                 const glu::FragmentSource       fragSource(tcu::StringTemplate(fragmentShaderSource).specialize(args));
476                 glu::ShaderProgram                      graphicsPipelineProgram (ctx.getRenderContext(), glu::ProgramSources() << vertSource << fragSource);
477
478                 tcu::TestLog& log = ctx.getLog();
479                 log << graphicsPipelineProgram;
480
481                 if (!graphicsPipelineProgram.isOk())
482                         TCU_THROW(InternalError, "failed to build program");
483
484                 ctx.beginSection("GL_INVALID_OPERATION is generated if GL_COMPUTE_WORK_GROUP_SIZE is queried for a program which has not been linked properly.");
485                 ctx.glGetProgramiv(graphicsPipelineProgram.getProgram(), GL_COMPUTE_WORK_GROUP_SIZE, &data[0]);
486                 ctx.expectError(GL_INVALID_OPERATION);
487                 ctx.endSection();
488
489                 ctx.glUseProgram(0);
490         }
491         ctx.endSection();
492 }
493
494 void invalid_dispatch_compute_indirect (NegativeTestContext& ctx)
495 {
496         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
497         map<string, string>                     args;
498         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
499
500         const glu::ComputeSource        compSource(tcu::StringTemplate(computeShaderSource).specialize(args));
501         glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << compSource);
502
503         tcu::TestLog& log = ctx.getLog();
504         log << program;
505
506         if (!program.isOk())
507                 TCU_THROW(InternalError, "failed to build program");
508
509         ctx.glUseProgram(program.getProgram());
510         ctx.expectError(GL_NO_ERROR);
511
512         static const struct
513         {
514                 GLuint numGroupsX;
515                 GLuint numGroupsY;
516                 GLuint numGroupsZ;
517         } data = {0, 0, 0};
518
519         {
520                 GLuint buffer;
521                 ctx.glGenBuffers(1, &buffer);
522                 ctx.glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, 0);
523                 ctx.expectError(GL_NO_ERROR);
524
525                 ctx.beginSection("GL_INVALID_OPERATION is generated by glDispatchComputeIndirect if zero is bound to GL_DISPATCH_INDIRECT_BUFFER.");
526                 GLintptr indirect = 0;
527                 ctx.glDispatchComputeIndirect(indirect);
528                 ctx.expectError(GL_INVALID_OPERATION);
529                 ctx.endSection();
530
531                 ctx.glDeleteBuffers(1, &buffer);
532         }
533
534         {
535                 GLuint buffer;
536                 ctx.glGenBuffers(1, &buffer);
537                 ctx.expectError(GL_NO_ERROR);
538
539                 ctx.glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, buffer);
540                 ctx.expectError(GL_NO_ERROR);
541
542                 ctx.glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
543                 ctx.expectError(GL_NO_ERROR);
544
545                 ctx.beginSection("GL_INVALID_OPERATION is generated by glDispatchComputeIndirect if data is sourced beyond the end of the buffer object.");
546                 GLintptr indirect = 1 << 10;
547                 ctx.glDispatchComputeIndirect(indirect);
548                 ctx.expectError(GL_INVALID_OPERATION);
549                 ctx.endSection();
550
551                 ctx.glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, 0);
552                 ctx.glDeleteBuffers(1, &buffer);
553         }
554
555         {
556                 ctx.beginSection("GL_INVALID_VALUE is generated by glDispatchComputeIndirect if the value of indirect is less than zero.");
557                 GLintptr indirect = -1;
558                 ctx.glDispatchComputeIndirect(indirect);
559                 ctx.expectError(GL_INVALID_VALUE);
560                 ctx.endSection();
561         }
562
563         {
564                 GLuint buffer;
565                 ctx.glGenBuffers(1, &buffer);
566                 ctx.expectError(GL_NO_ERROR);
567
568                 ctx.glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, buffer);
569                 ctx.expectError(GL_NO_ERROR);
570
571                 ctx.glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
572                 ctx.expectError(GL_NO_ERROR);
573
574                 ctx.beginSection("GL_INVALID_VALUE is generated by glDispatchComputeIndirect if indirect is not a multiple of the size, in basic machine units, of uint.");
575                 GLintptr indirect = sizeof(data) + 1;
576                 ctx.glDispatchComputeIndirect(indirect);
577                 ctx.expectError(GL_INVALID_VALUE);
578                 ctx.endSection();
579
580                 ctx.glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, 0);
581                 ctx.glDeleteBuffers(1, &buffer);
582         }
583 }
584
585 void invalid_maximum_work_group_counts (NegativeTestContext& ctx)
586 {
587         const bool                                      isES32  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
588         map<string, string>                     args;
589         args["GLSL_VERSION_STRING"]                     = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
590
591         const glu::ComputeSource        compSource(tcu::StringTemplate(computeShaderSource).specialize(args));
592         glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << compSource);
593
594         tcu::TestLog& log = ctx.getLog();
595         log << program;
596
597         if (!program.isOk())
598                 TCU_THROW(InternalError, "failed to build program");
599
600         ctx.glUseProgram(program.getProgram());
601         ctx.expectError(GL_NO_ERROR);
602
603         GLint workGroupCountX;
604         ctx.glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, (GLuint)0, &workGroupCountX);
605         ctx.expectError(GL_NO_ERROR);
606
607         ctx.beginSection("GL_INVALID_VALUE is generated by glDispatchCompute if <numGroupsX> array is larger than the maximum work group count for the x dimension.");
608         ctx.glDispatchCompute(workGroupCountX+1, 1, 1);
609         ctx.expectError(GL_INVALID_VALUE);
610         ctx.endSection();
611
612         GLint workGroupCountY;
613         ctx.glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, (GLuint)1, &workGroupCountY);
614         ctx.expectError(GL_NO_ERROR);
615
616         ctx.beginSection("GL_INVALID_VALUE is generated by glDispatchCompute if <numGroupsY> array is larger than the maximum work group count for the y dimension.");
617         ctx.glDispatchCompute(1, workGroupCountY+1, 1);
618         ctx.expectError(GL_INVALID_VALUE);
619         ctx.endSection();
620
621         GLint workGroupCountZ;
622         ctx.glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, (GLuint)2, &workGroupCountZ);
623         ctx.expectError(GL_NO_ERROR);
624
625         ctx.beginSection("GL_INVALID_VALUE is generated by glDispatchCompute if <numGroupsZ> array is larger than the maximum work group count for the z dimension.");
626         ctx.glDispatchCompute(1, 1, workGroupCountZ+1);
627         ctx.expectError(GL_INVALID_VALUE);
628         ctx.endSection();
629 }
630
631 void invalid_maximum_work_group_sizes (NegativeTestContext& ctx)
632 {
633         GLint maxWorkGroupSizeX;
634         ctx.glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, (GLuint)0, &maxWorkGroupSizeX);
635         ctx.expectError(GL_NO_ERROR);
636
637         GLint maxWorkGroupSizeY;
638         ctx.glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, (GLuint)1, &maxWorkGroupSizeY);
639         ctx.expectError(GL_NO_ERROR);
640
641         GLint maxWorkGroupSizeZ;
642         ctx.glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, (GLuint)2, &maxWorkGroupSizeZ);
643         ctx.expectError(GL_NO_ERROR);
644
645         GLint maxWorkGroupInvocations;
646         ctx.glGetIntegerv(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, &maxWorkGroupInvocations);
647         ctx.expectError(GL_NO_ERROR);
648
649         DE_ASSERT((maxWorkGroupSizeX * maxWorkGroupSizeY * maxWorkGroupSizeZ) > maxWorkGroupInvocations );
650
651         const bool                              isES32                  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
652         const char* const               shaderVersion   = isES32
653                                                                                         ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES)
654                                                                                         : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
655
656         static const struct
657         {
658                 GLint x;
659                 GLint y;
660                 GLint z;
661         } localWorkGroupSizeCases[] =
662         {
663                 {       maxWorkGroupSizeX+1,    1,                                              1                                               },
664                 {       1,                                              maxWorkGroupSizeY+1,    1                                               },
665                 {       1,                                              1,                                              maxWorkGroupSizeZ+1             },
666                 {       maxWorkGroupSizeX,              maxWorkGroupSizeY,              maxWorkGroupSizeZ               },
667         };
668
669         for (int testCase = 0; testCase < DE_LENGTH_OF_ARRAY(localWorkGroupSizeCases); ++testCase)
670         {
671                 std::ostringstream compShaderSource;
672
673                 compShaderSource        <<      shaderVersion << "\n"
674                                                         <<      "layout(local_size_x = " << localWorkGroupSizeCases[testCase].x << ", local_size_y = " << localWorkGroupSizeCases[testCase].y << ", local_size_z = " << localWorkGroupSizeCases[testCase].z << ") in;\n"
675                                                         <<      "void main (void)\n"
676                                                         <<      "{\n"
677                                                         <<      "}\n";
678
679                 const glu::ComputeSource        compSource(compShaderSource.str());
680                 glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << compSource);
681
682                 if (testCase == DE_LENGTH_OF_ARRAY(localWorkGroupSizeCases)-1)
683                 {
684                         bool testFailed = false;
685                         ctx.beginSection("A compile time or link error is generated if the maximum number of invocations in a single local work group (product of the three dimensions) is greater than GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS.");
686
687                         ctx.getLog() << program;
688                         testFailed = (program.getProgramInfo().linkOk) && (program.getShaderInfo(glu::SHADERTYPE_COMPUTE).compileOk);
689
690                         if (testFailed)
691                         {
692                                 const char* const message("Program was not expected to compile or link.");
693                                 ctx.getLog() << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
694                                 ctx.fail(message);
695                         }
696                 }
697                 else
698                 {
699                         ctx.beginSection("A compile time error is generated if the fixed local group size of the shader in any dimension is greater than the maximum supported.");
700                         verifyCompileError(ctx, program, glu::SHADERTYPE_COMPUTE);
701                 }
702
703                 ctx.endSection();
704         }
705 }
706
707 void invalid_layout_qualifiers (NegativeTestContext& ctx)
708 {
709         const bool                              isES32                  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
710         const char* const               shaderVersion   = isES32
711                                                                                         ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES)
712                                                                                         : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
713
714         {
715                 std::ostringstream compShaderSource;
716                 compShaderSource        <<      shaderVersion << "\n"
717                                                         <<      "void main (void)\n"
718                                                         <<      "{\n"
719                                                         <<      "}\n";
720
721                 const glu::ComputeSource        compSource(compShaderSource.str());
722                 glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << compSource);
723
724                 ctx.beginSection("A link error is generated if the compute shader program does not contain an input layout qualifier specifying a fixed local group size.");
725                 verifyLinkError(ctx, program);
726                 ctx.endSection();
727         }
728
729         {
730                 std::ostringstream compShaderSource;
731                 compShaderSource        <<      shaderVersion << "\n"
732                                                         <<      "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
733                                                         <<      "layout(local_size_x = 2, local_size_y = 2, local_size_z = 2) in;\n"
734                                                         <<      "void main (void)\n"
735                                                         <<      "{\n"
736                                                         <<      "}\n";
737
738                 const glu::ComputeSource        compSource(compShaderSource.str());
739                 glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << compSource);
740
741                 ctx.beginSection("A compile-time error is generated if a local work group size qualifier is declared more than once in the same shader.");
742                 verifyCompileError(ctx, program, glu::SHADERTYPE_COMPUTE);
743                 ctx.endSection();
744         }
745
746         {
747                 std::ostringstream compShaderSource;
748                 compShaderSource        <<      shaderVersion << "\n"
749                                                         <<      "out mediump vec4 fragColor;\n"
750                                                         <<      "\n"
751                                                         <<      "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
752                                                         <<      "void main (void)\n"
753                                                         <<      "{\n"
754                                                         <<      "}\n";
755
756                 const glu::ComputeSource        compSource(compShaderSource.str());
757                 glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << compSource);
758
759                 ctx.beginSection("A compile-time error is generated if a user defined output variable is declared in a compute shader.");
760                 verifyCompileError(ctx, program, glu::SHADERTYPE_COMPUTE);
761                 ctx.endSection();
762         }
763
764         {
765                 std::ostringstream compShaderSource;
766                 compShaderSource        <<      shaderVersion << "\n"
767                                                         <<      "uvec3 gl_NumWorkGroups;\n"
768                                                         <<      "uvec3 gl_WorkGroupSize;\n"
769                                                         <<      "uvec3 gl_WorkGroupID;\n"
770                                                         <<      "uvec3 gl_LocalInvocationID;\n"
771                                                         <<      "uvec3 gl_GlobalInvocationID;\n"
772                                                         <<      "uvec3 gl_LocalInvocationIndex;\n"
773                                                         <<      "\n"
774                                                         <<      "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
775                                                         <<      "void main (void)\n"
776                                                         <<      "{\n"
777                                                         <<      "}\n";
778
779                 const glu::ComputeSource        compSource(compShaderSource.str());
780                 glu::ShaderProgram                      program(ctx.getRenderContext(), glu::ProgramSources() << compSource);
781
782                 ctx.beginSection("A compile time or link error is generated if compute shader built-in variables are redeclared.");
783                 bool testFailed = false;
784
785                 tcu::TestLog& log = ctx.getLog();
786                 log << program;
787
788                 testFailed = (program.getProgramInfo().linkOk) && (program.getShaderInfo(glu::SHADERTYPE_COMPUTE).compileOk);
789
790                 if (testFailed)
791                 {
792                         const char* const message("Program was not expected to compile or link.");
793                         log << tcu::TestLog::Message << message << tcu::TestLog::EndMessage;
794                         ctx.fail(message);
795                 }
796
797                 ctx.endSection();
798         }
799 }
800
801 void invalid_write_built_in_constants (NegativeTestContext& ctx)
802 {
803         if ((!ctx.isExtensionSupported("GL_EXT_tessellation_shader") && !ctx.isExtensionSupported("GL_OES_tessellation_shader")) ||
804             (!ctx.isExtensionSupported("GL_EXT_geometry_shader") && !ctx.isExtensionSupported("GL_OES_geometry_shader")))
805         {
806                 TCU_THROW(NotSupportedError, "tessellation and geometry shader extensions not supported");
807         }
808
809         const bool                                      isES32                  = glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2));
810         map<string, string>                     args;
811
812         args["GLSL_VERSION_STRING"]                                     =       isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
813         args["GLSL_TESS_EXTENSION_STRING"]                      =       isES32 ? "" : "#extension GL_EXT_tessellation_shader : require";
814         args["COMPUTE_BUILT_IN_CONSTANTS_STRING"]       =       "       gl_MaxComputeWorkGroupCount       = ivec3(65535, 65535, 65535);\n"
815                                                                                                         "       gl_MaxComputeWorkGroupCount       = ivec3(1024, 1024, 64);\n"
816                                                                                                         "       gl_MaxComputeWorkGroupSize        = ivec3(512);\n"
817                                                                                                         "       gl_MaxComputeUniformComponents    = 512;\n"
818                                                                                                         "       gl_MaxComputeTextureImageUnits    = 16;\n"
819                                                                                                         "       gl_MaxComputeImageUniforms        = 8;\n"
820                                                                                                         "       gl_MaxComputeAtomicCounters       = 8;\n"
821                                                                                                         "       gl_MaxComputeAtomicCounterBuffers = 1;\n";
822
823         const glu::VertexSource                                 vertSource              (tcu::StringTemplate(genBuiltInSource(glu::SHADERTYPE_VERTEX)).specialize(args));
824         const glu::FragmentSource                               fragSource              (tcu::StringTemplate(genBuiltInSource(glu::SHADERTYPE_FRAGMENT)).specialize(args));
825         const glu::TessellationControlSource    tessCtrlSource  (tcu::StringTemplate(genBuiltInSource(glu::SHADERTYPE_TESSELLATION_CONTROL)).specialize(args));
826         const glu::TessellationEvaluationSource tessEvalSource  (tcu::StringTemplate(genBuiltInSource(glu::SHADERTYPE_TESSELLATION_EVALUATION)).specialize(args));
827         const glu::GeometrySource                               geometrySource  (tcu::StringTemplate(genBuiltInSource(glu::SHADERTYPE_GEOMETRY)).specialize(args));
828         const glu::ComputeSource                                computeSource   (tcu::StringTemplate(genBuiltInSource(glu::SHADERTYPE_COMPUTE)).specialize(args));
829
830         glu::ShaderProgram      vertProgram             (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << vertSource);
831         glu::ShaderProgram      fragProgram             (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << fragSource);
832         glu::ShaderProgram      tessCtrlProgram (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << tessCtrlSource);
833         glu::ShaderProgram      tessEvalProgram (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << tessEvalSource);
834         glu::ShaderProgram      geometryProgram (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << geometrySource);
835         glu::ShaderProgram      computeProgram  (ctx.getRenderContext(), glu::ProgramSources() << glu::ProgramSeparable(true) << computeSource);
836
837         ctx.beginSection("A compile time is generated if compute built-in constants provided in all shaders are written to.");
838         verifyCompileError(ctx, vertProgram, glu::SHADERTYPE_VERTEX);
839         verifyCompileError(ctx, fragProgram, glu::SHADERTYPE_FRAGMENT);
840         verifyCompileError(ctx, tessCtrlProgram, glu::SHADERTYPE_TESSELLATION_CONTROL);
841         verifyCompileError(ctx, tessEvalProgram, glu::SHADERTYPE_TESSELLATION_EVALUATION);
842         verifyCompileError(ctx, geometryProgram, glu::SHADERTYPE_GEOMETRY);
843         verifyCompileError(ctx, computeProgram, glu::SHADERTYPE_COMPUTE);
844         ctx.endSection();
845 }
846
847 } // anonymous
848
849 std::vector<FunctionContainer> getNegativeComputeTestFunctions (void)
850 {
851         const FunctionContainer funcs[] =
852         {
853                 { program_not_active,                                   "program_not_active",                                   "Use dispatch commands with no active program"                                                                  },
854                 { invalid_program_query,                                "invalid_program_query",                                "Querying GL_COMPUTE_WORK_GROUP_SIZE with glGetProgramiv() on invalid programs" },
855                 { invalid_dispatch_compute_indirect,    "invalid_dispatch_compute_indirect",    "Invalid glDispatchComputeIndirect usage"                                                                               },
856                 { invalid_maximum_work_group_counts,    "invalid_maximum_work_group_counts",    "Maximum workgroup counts for dispatch commands"                                                                },
857                 { invalid_maximum_work_group_sizes,             "invalid_maximum_work_group_sizes",             "Maximum local workgroup sizes declared in compute shaders"                                             },
858                 { invalid_layout_qualifiers,                    "invalid_layout_qualifiers",                    "Invalid layout qualifiers in compute shaders"                                                                  },
859                 { invalid_write_built_in_constants,             "invalid_write_built_in_constants",             "Invalid writes to built-in compute shader constants"                                                   },
860                 { exceed_uniform_block_limit,                   "exceed_uniform_block_limit",                   "Link error when shader exceeds GL_MAX_COMPUTE_UNIFORM_BLOCKS"                                  },
861                 { exceed_shader_storage_block_limit,    "exceed_shader_storage_block_limit",    "Link error when shader exceeds GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS"                   },
862                 { exceed_texture_image_units_limit,             "exceed_texture_image_units_limit",             "Link error when shader exceeds GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS"                             },
863                 { exceed_image_uniforms_limit,                  "exceed_image_uniforms_limit",                  "Link error when shader exceeds GL_MAX_COMPUTE_IMAGE_UNIFORMS"                                  },
864                 { exceed_shared_memory_size_limit,              "exceed_shared_memory_size_limit",              "Link error when shader exceeds GL_MAX_COMPUTE_SHARED_MEMORY_SIZE"                              },
865                 { exceed_uniform_components_limit,              "exceed_uniform_components_limit",              "Link error when shader exceeds GL_MAX_COMPUTE_UNIFORM_COMPONENTS"                              },
866                 { exceed_atomic_counter_buffer_limit,   "exceed_atomic_counter_buffer_limit",   "Link error when shader exceeds GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS"                  },
867                 { exceed_atomic_counters_limit,                 "exceed_atomic_counters_limit",                 "Link error when shader exceeds GL_MAX_COMPUTE_ATOMIC_COUNTERS"                                 },
868         };
869
870         return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
871 }
872
873 } // NegativeTestShared
874 } // Functional
875 } // gles31
876 } // deqp