1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
6 
7 #include <stdint.h>
8 
9 #include "base/command_line.h"
10 #include "gpu/command_buffer/common/gles2_cmd_format.h"
11 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
12 #include "gpu/command_buffer/service/context_group.h"
13 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
14 #include "gpu/command_buffer/service/program_manager.h"
15 #include "gpu/command_buffer/service/test_helper.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "ui/gl/gl_mock.h"
18 
19 using ::gl::MockGLInterface;
20 using ::testing::_;
21 using ::testing::AnyNumber;
22 using ::testing::DoAll;
23 using ::testing::InSequence;
24 using ::testing::MatcherCast;
25 using ::testing::Pointee;
26 using ::testing::Return;
27 using ::testing::SetArrayArgument;
28 using ::testing::SetArgPointee;
29 using ::testing::StrEq;
30 
31 namespace gpu {
32 namespace gles2 {
33 
34 class GLES2DecoderTest2 : public GLES2DecoderTestBase {
35  public:
36   GLES2DecoderTest2() = default;
37 
TestAcceptedUniform(GLenum uniform_type,UniformApiType accepts_apis,bool es3_enabled)38   void TestAcceptedUniform(GLenum uniform_type,
39                            UniformApiType accepts_apis,
40                            bool es3_enabled) {
41     SetupShaderForUniform(uniform_type);
42     bool valid_uniform = false;
43 
44     EXPECT_CALL(*gl_, Uniform1i(1, _)).Times(AnyNumber());
45     EXPECT_CALL(*gl_, Uniform1iv(1, _, _)).Times(AnyNumber());
46     EXPECT_CALL(*gl_, Uniform2iv(1, _, _)).Times(AnyNumber());
47     EXPECT_CALL(*gl_, Uniform3iv(1, _, _)).Times(AnyNumber());
48     EXPECT_CALL(*gl_, Uniform4iv(1, _, _)).Times(AnyNumber());
49     EXPECT_CALL(*gl_, Uniform1f(1, _)).Times(AnyNumber());
50     EXPECT_CALL(*gl_, Uniform1fv(1, _, _)).Times(AnyNumber());
51     EXPECT_CALL(*gl_, Uniform2fv(1, _, _)).Times(AnyNumber());
52     EXPECT_CALL(*gl_, Uniform3fv(1, _, _)).Times(AnyNumber());
53     EXPECT_CALL(*gl_, Uniform4fv(1, _, _)).Times(AnyNumber());
54     EXPECT_CALL(*gl_, UniformMatrix2fv(1, _, _, _)).Times(AnyNumber());
55     EXPECT_CALL(*gl_, UniformMatrix3fv(1, _, _, _)).Times(AnyNumber());
56     EXPECT_CALL(*gl_, UniformMatrix4fv(1, _, _, _)).Times(AnyNumber());
57     if (es3_enabled) {
58       EXPECT_CALL(*gl_, Uniform1uiv(1, _, _)).Times(AnyNumber());
59       EXPECT_CALL(*gl_, Uniform2uiv(1, _, _)).Times(AnyNumber());
60       EXPECT_CALL(*gl_, Uniform3uiv(1, _, _)).Times(AnyNumber());
61       EXPECT_CALL(*gl_, Uniform4uiv(1, _, _)).Times(AnyNumber());
62       EXPECT_CALL(*gl_, UniformMatrix2fv(1, _, _, _)).Times(AnyNumber());
63       EXPECT_CALL(*gl_, UniformMatrix3fv(1, _, _, _)).Times(AnyNumber());
64       EXPECT_CALL(*gl_, UniformMatrix4fv(1, _, _, _)).Times(AnyNumber());
65       EXPECT_CALL(*gl_, UniformMatrix2x3fv(1, _, _, _)).Times(AnyNumber());
66       EXPECT_CALL(*gl_, UniformMatrix2x4fv(1, _, _, _)).Times(AnyNumber());
67       EXPECT_CALL(*gl_, UniformMatrix3x2fv(1, _, _, _)).Times(AnyNumber());
68       EXPECT_CALL(*gl_, UniformMatrix3x4fv(1, _, _, _)).Times(AnyNumber());
69       EXPECT_CALL(*gl_, UniformMatrix4x2fv(1, _, _, _)).Times(AnyNumber());
70       EXPECT_CALL(*gl_, UniformMatrix4x3fv(1, _, _, _)).Times(AnyNumber());
71     }
72 
73     {
74       valid_uniform = (accepts_apis & UniformApiType::kUniform1i) !=
75                       UniformApiType::kUniformNone;
76       cmds::Uniform1i cmd;
77       cmd.Init(1, 2);
78       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
79       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
80                 GetGLError());
81     }
82 
83     {
84       valid_uniform = (accepts_apis & UniformApiType::kUniform1i) !=
85                       UniformApiType::kUniformNone;
86       cmds::Uniform1ivImmediate& cmd =
87           *GetImmediateAs<cmds::Uniform1ivImmediate>();
88       GLint data[2][1] = {{0}};
89       cmd.Init(1, 2, &data[0][0]);
90       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
91       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
92                 GetGLError());
93     }
94 
95     {
96       valid_uniform = (accepts_apis & UniformApiType::kUniform2i) !=
97                       UniformApiType::kUniformNone;
98       cmds::Uniform2i cmd;
99       cmd.Init(1, 2, 3);
100       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
101       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
102                 GetGLError());
103     }
104 
105     {
106       valid_uniform = (accepts_apis & UniformApiType::kUniform2i) !=
107                       UniformApiType::kUniformNone;
108       cmds::Uniform2ivImmediate& cmd =
109           *GetImmediateAs<cmds::Uniform2ivImmediate>();
110       GLint data[2][2] = {{0}};
111       cmd.Init(1, 2, &data[0][0]);
112       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
113       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
114                 GetGLError());
115     }
116 
117     {
118       valid_uniform = (accepts_apis & UniformApiType::kUniform3i) !=
119                       UniformApiType::kUniformNone;
120       cmds::Uniform3i cmd;
121       cmd.Init(1, 2, 3, 4);
122       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
123       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
124                 GetGLError());
125     }
126 
127     {
128       valid_uniform = (accepts_apis & UniformApiType::kUniform3i) !=
129                       UniformApiType::kUniformNone;
130       cmds::Uniform3ivImmediate& cmd =
131           *GetImmediateAs<cmds::Uniform3ivImmediate>();
132       GLint data[2][3] = {{0}};
133       cmd.Init(1, 2, &data[0][0]);
134       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
135       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
136                 GetGLError());
137     }
138 
139     {
140       valid_uniform = (accepts_apis & UniformApiType::kUniform4i) !=
141                       UniformApiType::kUniformNone;
142       cmds::Uniform4i cmd;
143       cmd.Init(1, 2, 3, 4, 5);
144       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
145       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
146                 GetGLError());
147     }
148 
149     {
150       valid_uniform = (accepts_apis & UniformApiType::kUniform4i) !=
151                       UniformApiType::kUniformNone;
152       cmds::Uniform4ivImmediate& cmd =
153           *GetImmediateAs<cmds::Uniform4ivImmediate>();
154       GLint data[2][4] = {{0}};
155       cmd.Init(1, 2, &data[0][0]);
156       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
157       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
158                 GetGLError());
159     }
160 
161     ////////////////////
162 
163     {
164       valid_uniform = (accepts_apis & UniformApiType::kUniform1f) !=
165                       UniformApiType::kUniformNone;
166       cmds::Uniform1f cmd;
167       cmd.Init(1, 2);
168       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
169       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
170                 GetGLError());
171     }
172 
173     {
174       valid_uniform = (accepts_apis & UniformApiType::kUniform1f) !=
175                       UniformApiType::kUniformNone;
176       cmds::Uniform1fvImmediate& cmd =
177           *GetImmediateAs<cmds::Uniform1fvImmediate>();
178       GLfloat data[2][1] = {{0.0f}};
179       cmd.Init(1, 2, &data[0][0]);
180       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
181       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
182                 GetGLError());
183     }
184 
185     {
186       valid_uniform = (accepts_apis & UniformApiType::kUniform2f) !=
187                       UniformApiType::kUniformNone;
188       cmds::Uniform2f cmd;
189       cmd.Init(1, 2, 3);
190       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
191       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
192                 GetGLError());
193     }
194 
195     {
196       valid_uniform = (accepts_apis & UniformApiType::kUniform2f) !=
197                       UniformApiType::kUniformNone;
198       cmds::Uniform2fvImmediate& cmd =
199           *GetImmediateAs<cmds::Uniform2fvImmediate>();
200       GLfloat data[2][2] = {{0.0f}};
201       cmd.Init(1, 2, &data[0][0]);
202       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
203       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
204                 GetGLError());
205     }
206 
207     {
208       valid_uniform = (accepts_apis & UniformApiType::kUniform3f) !=
209                       UniformApiType::kUniformNone;
210       cmds::Uniform3f cmd;
211       cmd.Init(1, 2, 3, 4);
212       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
213       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
214                 GetGLError());
215     }
216 
217     {
218       valid_uniform = (accepts_apis & UniformApiType::kUniform3f) !=
219                       UniformApiType::kUniformNone;
220       cmds::Uniform3fvImmediate& cmd =
221           *GetImmediateAs<cmds::Uniform3fvImmediate>();
222       GLfloat data[2][3] = {{0.0f}};
223       cmd.Init(1, 2, &data[0][0]);
224       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
225       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
226                 GetGLError());
227     }
228 
229     {
230       valid_uniform = (accepts_apis & UniformApiType::kUniform4f) !=
231                       UniformApiType::kUniformNone;
232       cmds::Uniform4f cmd;
233       cmd.Init(1, 2, 3, 4, 5);
234       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
235       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
236                 GetGLError());
237     }
238 
239     {
240       valid_uniform = (accepts_apis & UniformApiType::kUniform4f) !=
241                       UniformApiType::kUniformNone;
242       cmds::Uniform4fvImmediate& cmd =
243           *GetImmediateAs<cmds::Uniform4fvImmediate>();
244       GLfloat data[2][4] = {{0.0f}};
245       cmd.Init(1, 2, &data[0][0]);
246       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
247       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
248                 GetGLError());
249     }
250 
251     {
252       valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix2f) !=
253                       UniformApiType::kUniformNone;
254       cmds::UniformMatrix2fvImmediate& cmd =
255           *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
256       GLfloat data[2][2 * 2] = {{0.0f}};
257 
258       cmd.Init(1, 2, false, &data[0][0]);
259       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
260       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
261                 GetGLError());
262     }
263 
264     {
265       valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix3f) !=
266                       UniformApiType::kUniformNone;
267       cmds::UniformMatrix3fvImmediate& cmd =
268           *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
269       GLfloat data[2][3 * 3] = {{0.0f}};
270       cmd.Init(1, 2, false, &data[0][0]);
271       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
272       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
273                 GetGLError());
274     }
275 
276     {
277       valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix4f) !=
278                       UniformApiType::kUniformNone;
279       cmds::UniformMatrix4fvImmediate& cmd =
280           *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
281       GLfloat data[2][4 * 4] = {{0.0f}};
282       cmd.Init(1, 2, false, &data[0][0]);
283       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
284       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
285                 GetGLError());
286     }
287 
288     if (!es3_enabled) {
289       {
290         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix2f) !=
291                         UniformApiType::kUniformNone;
292         cmds::UniformMatrix2fvImmediate& cmd =
293             *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
294         GLfloat data[2][2 * 2] = {{0.0f}};
295 
296         cmd.Init(1, 2, true, &data[0][0]);
297         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
298         EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
299       }
300 
301       {
302         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix3f) !=
303                         UniformApiType::kUniformNone;
304         cmds::UniformMatrix3fvImmediate& cmd =
305             *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
306         GLfloat data[2][3 * 3] = {{0.0f}};
307         cmd.Init(1, 2, true, &data[0][0]);
308         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
309         EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
310       }
311 
312       {
313         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix4f) !=
314                         UniformApiType::kUniformNone;
315         cmds::UniformMatrix4fvImmediate& cmd =
316             *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
317         GLfloat data[2][4 * 4] = {{0.0f}};
318         cmd.Init(1, 2, true, &data[0][0]);
319         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
320         EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
321       }
322     }
323 
324     if (es3_enabled) {
325       {
326         valid_uniform = (accepts_apis & UniformApiType::kUniform1ui) !=
327                         UniformApiType::kUniformNone;
328         cmds::Uniform1ui cmd;
329         cmd.Init(1, 2);
330         EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
331         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
332                   GetGLError());
333       }
334 
335       {
336         valid_uniform = (accepts_apis & UniformApiType::kUniform1ui) !=
337                         UniformApiType::kUniformNone;
338         cmds::Uniform1uivImmediate& cmd =
339             *GetImmediateAs<cmds::Uniform1uivImmediate>();
340         GLuint data[2][1] = {{0}};
341         cmd.Init(1, 2, &data[0][0]);
342         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
343         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
344                   GetGLError());
345       }
346 
347       {
348         valid_uniform = (accepts_apis & UniformApiType::kUniform2ui) !=
349                         UniformApiType::kUniformNone;
350         cmds::Uniform2ui cmd;
351         cmd.Init(1, 2, 3);
352         EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
353         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
354                   GetGLError());
355       }
356 
357       {
358         valid_uniform = (accepts_apis & UniformApiType::kUniform2ui) !=
359                         UniformApiType::kUniformNone;
360         cmds::Uniform2uivImmediate& cmd =
361             *GetImmediateAs<cmds::Uniform2uivImmediate>();
362         GLuint data[2][2] = {{0}};
363         cmd.Init(1, 2, &data[0][0]);
364         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
365         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
366                   GetGLError());
367       }
368 
369       {
370         valid_uniform = (accepts_apis & UniformApiType::kUniform3ui) !=
371                         UniformApiType::kUniformNone;
372         cmds::Uniform3ui cmd;
373         cmd.Init(1, 2, 3, 4);
374         EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
375         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
376                   GetGLError());
377       }
378 
379       {
380         valid_uniform = (accepts_apis & UniformApiType::kUniform3ui) !=
381                         UniformApiType::kUniformNone;
382         cmds::Uniform3uivImmediate& cmd =
383             *GetImmediateAs<cmds::Uniform3uivImmediate>();
384         GLuint data[2][3] = {{0}};
385         cmd.Init(1, 2, &data[0][0]);
386         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
387         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
388                   GetGLError());
389       }
390 
391       {
392         valid_uniform = (accepts_apis & UniformApiType::kUniform4ui) !=
393                         UniformApiType::kUniformNone;
394         cmds::Uniform4ui cmd;
395         cmd.Init(1, 2, 3, 4, 5);
396         EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
397         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
398                   GetGLError());
399       }
400 
401       {
402         valid_uniform = (accepts_apis & UniformApiType::kUniform4ui) !=
403                         UniformApiType::kUniformNone;
404         cmds::Uniform4uivImmediate& cmd =
405             *GetImmediateAs<cmds::Uniform4uivImmediate>();
406         GLuint data[2][4] = {{0}};
407         cmd.Init(1, 2, &data[0][0]);
408         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
409         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
410                   GetGLError());
411       }
412 
413       {
414         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix2x3f) !=
415                         UniformApiType::kUniformNone;
416         cmds::UniformMatrix2x3fvImmediate& cmd =
417             *GetImmediateAs<cmds::UniformMatrix2x3fvImmediate>();
418         GLfloat data[2][2 * 3] = {{0.0f}};
419 
420         cmd.Init(1, 2, false, &data[0][0]);
421         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
422         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
423                   GetGLError());
424       }
425 
426       {
427         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix2x4f) !=
428                         UniformApiType::kUniformNone;
429         cmds::UniformMatrix2x4fvImmediate& cmd =
430             *GetImmediateAs<cmds::UniformMatrix2x4fvImmediate>();
431         GLfloat data[2][2 * 4] = {{0.0f}};
432 
433         cmd.Init(1, 2, false, &data[0][0]);
434         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
435         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
436                   GetGLError());
437       }
438 
439       {
440         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix3x2f) !=
441                         UniformApiType::kUniformNone;
442         cmds::UniformMatrix3x2fvImmediate& cmd =
443             *GetImmediateAs<cmds::UniformMatrix3x2fvImmediate>();
444         GLfloat data[2][3 * 2] = {{0.0f}};
445 
446         cmd.Init(1, 2, false, &data[0][0]);
447         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
448         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
449                   GetGLError());
450       }
451 
452       {
453         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix3x4f) !=
454                         UniformApiType::kUniformNone;
455         cmds::UniformMatrix3x4fvImmediate& cmd =
456             *GetImmediateAs<cmds::UniformMatrix3x4fvImmediate>();
457         GLfloat data[2][3 * 4] = {{0.0f}};
458 
459         cmd.Init(1, 2, false, &data[0][0]);
460         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
461         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
462                   GetGLError());
463       }
464 
465       {
466         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix4x2f) !=
467                         UniformApiType::kUniformNone;
468         cmds::UniformMatrix4x2fvImmediate& cmd =
469             *GetImmediateAs<cmds::UniformMatrix4x2fvImmediate>();
470         GLfloat data[2][4 * 2] = {{0.0f}};
471 
472         cmd.Init(1, 2, false, &data[0][0]);
473         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
474         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
475                   GetGLError());
476       }
477 
478       {
479         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix4x3f) !=
480                         UniformApiType::kUniformNone;
481         cmds::UniformMatrix4x3fvImmediate& cmd =
482             *GetImmediateAs<cmds::UniformMatrix4x3fvImmediate>();
483         GLfloat data[2][4 * 3] = {{0.0f}};
484 
485         cmd.Init(1, 2, false, &data[0][0]);
486         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
487         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
488                   GetGLError());
489       }
490 
491       {
492         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix2f) !=
493                         UniformApiType::kUniformNone;
494         cmds::UniformMatrix2fvImmediate& cmd =
495             *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
496         GLfloat data[2][2 * 2] = {{0.0f}};
497 
498         cmd.Init(1, 2, true, &data[0][0]);
499         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
500         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
501                   GetGLError());
502       }
503 
504       {
505         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix3f) !=
506                         UniformApiType::kUniformNone;
507         cmds::UniformMatrix3fvImmediate& cmd =
508             *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
509         GLfloat data[2][3 * 3] = {{0.0f}};
510         cmd.Init(1, 2, true, &data[0][0]);
511         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
512         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
513                   GetGLError());
514       }
515 
516       {
517         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix4f) !=
518                         UniformApiType::kUniformNone;
519         cmds::UniformMatrix4fvImmediate& cmd =
520             *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
521         GLfloat data[2][4 * 4] = {{0.0f}};
522         cmd.Init(1, 2, true, &data[0][0]);
523         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
524         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
525                   GetGLError());
526       }
527 
528       {
529         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix2x3f) !=
530                         UniformApiType::kUniformNone;
531         cmds::UniformMatrix2x3fvImmediate& cmd =
532             *GetImmediateAs<cmds::UniformMatrix2x3fvImmediate>();
533         GLfloat data[2][2 * 3] = {{0.0f}};
534 
535         cmd.Init(1, 2, true, &data[0][0]);
536         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
537         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
538                   GetGLError());
539       }
540 
541       {
542         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix2x4f) !=
543                         UniformApiType::kUniformNone;
544         cmds::UniformMatrix2x4fvImmediate& cmd =
545             *GetImmediateAs<cmds::UniformMatrix2x4fvImmediate>();
546         GLfloat data[2][2 * 4] = {{0.0f}};
547 
548         cmd.Init(1, 2, true, &data[0][0]);
549         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
550         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
551                   GetGLError());
552       }
553 
554       {
555         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix3x2f) !=
556                         UniformApiType::kUniformNone;
557         cmds::UniformMatrix3x2fvImmediate& cmd =
558             *GetImmediateAs<cmds::UniformMatrix3x2fvImmediate>();
559         GLfloat data[2][3 * 2] = {{0.0f}};
560 
561         cmd.Init(1, 2, true, &data[0][0]);
562         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
563         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
564                   GetGLError());
565       }
566 
567       {
568         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix3x4f) !=
569                         UniformApiType::kUniformNone;
570         cmds::UniformMatrix3x4fvImmediate& cmd =
571             *GetImmediateAs<cmds::UniformMatrix3x4fvImmediate>();
572         GLfloat data[2][3 * 4] = {{0.0f}};
573 
574         cmd.Init(1, 2, true, &data[0][0]);
575         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
576         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
577                   GetGLError());
578       }
579 
580       {
581         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix4x2f) !=
582                         UniformApiType::kUniformNone;
583         cmds::UniformMatrix4x2fvImmediate& cmd =
584             *GetImmediateAs<cmds::UniformMatrix4x2fvImmediate>();
585         GLfloat data[2][4 * 2] = {{0.0f}};
586 
587         cmd.Init(1, 2, true, &data[0][0]);
588         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
589         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
590                   GetGLError());
591       }
592 
593       {
594         valid_uniform = (accepts_apis & UniformApiType::kUniformMatrix4x3f) !=
595                         UniformApiType::kUniformNone;
596         cmds::UniformMatrix4x3fvImmediate& cmd =
597             *GetImmediateAs<cmds::UniformMatrix4x3fvImmediate>();
598         GLfloat data[2][4 * 3] = {{0.0f}};
599 
600         cmd.Init(1, 2, true, &data[0][0]);
601         EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
602         EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
603                   GetGLError());
604       }
605     }
606   }
607 };
608 
609 class GLES3DecoderTest2 : public GLES2DecoderTest2 {
610  public:
GLES3DecoderTest2()611   GLES3DecoderTest2() { shader_language_version_ = 300; }
612  protected:
SetUp()613   void SetUp() override {
614     InitState init;
615     init.gl_version = "OpenGL ES 3.0";
616     init.bind_generates_resource = true;
617     init.context_type = CONTEXT_TYPE_OPENGLES3;
618     InitDecoder(init);
619   }
620 };
621 
622 INSTANTIATE_TEST_SUITE_P(Service, GLES2DecoderTest2, ::testing::Bool());
623 INSTANTIATE_TEST_SUITE_P(Service, GLES3DecoderTest2, ::testing::Bool());
624 
625 template <>
SpecializedSetup(bool)626 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramInfoLog, 0>(
627     bool /* valid */) {
628   const GLuint kClientVertexShaderId = 5001;
629   const GLuint kServiceVertexShaderId = 6001;
630   const GLuint kClientFragmentShaderId = 5002;
631   const GLuint kServiceFragmentShaderId = 6002;
632   const char* log = "hello";  // Matches auto-generated unit test.
633   DoCreateShader(
634       GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId);
635   DoCreateShader(
636       GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId);
637 
638   TestHelper::SetShaderStates(
639       gl_.get(), GetShader(kClientVertexShaderId), true);
640   TestHelper::SetShaderStates(
641       gl_.get(), GetShader(kClientFragmentShaderId), true);
642 
643   InSequence dummy;
644   EXPECT_CALL(*gl_,
645               AttachShader(kServiceProgramId, kServiceVertexShaderId))
646       .Times(1)
647       .RetiresOnSaturation();
648   EXPECT_CALL(*gl_,
649               AttachShader(kServiceProgramId, kServiceFragmentShaderId))
650       .Times(1)
651       .RetiresOnSaturation();
652   EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId))
653       .Times(1)
654       .RetiresOnSaturation();
655   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
656       .WillOnce(SetArgPointee<2>(1));
657   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _))
658       .WillOnce(SetArgPointee<2>(strlen(log) + 1))
659       .RetiresOnSaturation();
660   EXPECT_CALL(*gl_, GetProgramInfoLog(kServiceProgramId, strlen(log) + 1, _, _))
661       .WillOnce(DoAll(SetArgPointee<2>(strlen(log)),
662                       SetArrayArgument<3>(log, log + strlen(log) + 1)))
663       .RetiresOnSaturation();
664   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTES, _))
665       .WillOnce(SetArgPointee<2>(0));
666   EXPECT_CALL(
667       *gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
668       .WillOnce(SetArgPointee<2>(0));
669   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
670       .WillOnce(SetArgPointee<2>(0));
671 
672   Program* program = GetProgram(client_program_id_);
673   ASSERT_TRUE(program != nullptr);
674 
675   cmds::AttachShader attach_cmd;
676   attach_cmd.Init(client_program_id_, kClientVertexShaderId);
677   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
678 
679   attach_cmd.Init(client_program_id_, kClientFragmentShaderId);
680   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
681 
682   program->Link(nullptr, Program::kCountOnlyStaticallyUsed, this);
683 }
684 
685 template <>
SpecializedSetup(bool)686 void GLES2DecoderTestBase::SpecializedSetup<
687     cmds::GetRenderbufferParameteriv, 0>(
688         bool /* valid */) {
689   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
690                     kServiceRenderbufferId);
691 }
692 
693 template <>
SpecializedSetup(bool valid)694 void GLES2DecoderTestBase::SpecializedSetup<cmds::RenderbufferStorage, 0>(
695     bool valid) {
696   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
697                     kServiceRenderbufferId);
698   if (valid) {
699     EnsureRenderbufferBound(false);
700     EXPECT_CALL(*gl_, GetError())
701         .WillOnce(Return(GL_NO_ERROR))
702         .RetiresOnSaturation();
703     EXPECT_CALL(*gl_,
704                 RenderbufferStorageEXT(GL_RENDERBUFFER, _, 3, 4))
705         .Times(1)
706         .RetiresOnSaturation();
707     EXPECT_CALL(*gl_, GetError())
708         .WillOnce(Return(GL_NO_ERROR))
709         .RetiresOnSaturation();
710   }
711 }
712 
713 template <>
SpecializedSetup(bool valid)714 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXTImmediate, 0>(
715     bool valid) {
716   if (!valid) {
717     // Make the client_query_id_ so that trying to make it again
718     // will fail.
719     cmds::GenQueriesEXTImmediate& cmd =
720         *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
721     cmd.Init(1, &client_query_id_);
722     EXPECT_EQ(error::kNoError,
723               ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
724   }
725 }
726 
727 template <>
SpecializedSetup(bool valid)728 void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXTImmediate, 0>(
729     bool valid) {
730   if (valid) {
731     // Make the client_query_id_ so that trying to delete it will succeed.
732     cmds::GenQueriesEXTImmediate& cmd =
733         *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
734     cmd.Init(1, &client_query_id_);
735     EXPECT_EQ(error::kNoError,
736               ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
737   }
738 }
739 
740 template <>
SpecializedSetup(bool)741 void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(
742     bool /* valid */) {
743   const GLuint kClientVertexShaderId = 5001;
744   const GLuint kServiceVertexShaderId = 6001;
745   const GLuint kClientFragmentShaderId = 5002;
746   const GLuint kServiceFragmentShaderId = 6002;
747   DoCreateShader(
748       GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId);
749   DoCreateShader(
750       GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId);
751 
752   TestHelper::SetShaderStates(
753       gl_.get(), GetShader(kClientVertexShaderId), true);
754   TestHelper::SetShaderStates(
755       gl_.get(), GetShader(kClientFragmentShaderId), true);
756 
757   InSequence dummy;
758   EXPECT_CALL(*gl_,
759               AttachShader(kServiceProgramId, kServiceVertexShaderId))
760       .Times(1)
761       .RetiresOnSaturation();
762   EXPECT_CALL(*gl_,
763               AttachShader(kServiceProgramId, kServiceFragmentShaderId))
764       .Times(1)
765       .RetiresOnSaturation();
766   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
767       .WillOnce(SetArgPointee<2>(1));
768   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _))
769       .WillOnce(SetArgPointee<2>(0))
770       .RetiresOnSaturation();
771   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTES, _))
772       .WillOnce(SetArgPointee<2>(0));
773   EXPECT_CALL(
774       *gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
775       .WillOnce(SetArgPointee<2>(0));
776   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
777       .WillOnce(SetArgPointee<2>(0));
778 
779   cmds::AttachShader attach_cmd;
780   attach_cmd.Init(client_program_id_, kClientVertexShaderId);
781   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
782 
783   attach_cmd.Init(client_program_id_, kClientFragmentShaderId);
784   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
785 }
786 
787 template <>
SpecializedSetup(bool)788 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1f, 0>(
789     bool /* valid */) {
790   SetupShaderForUniform(GL_FLOAT);
791 }
792 
793 template <>
SpecializedSetup(bool)794 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fvImmediate, 0>(
795     bool /* valid */) {
796   SetupShaderForUniform(GL_FLOAT);
797 }
798 
799 template <>
SpecializedSetup(bool)800 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1ivImmediate, 0>(
801     bool /* valid */) {
802   SetupShaderForUniform(GL_INT);
803 }
804 
805 template <>
SpecializedSetup(bool)806 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2f, 0>(
807     bool /* valid */) {
808   SetupShaderForUniform(GL_FLOAT_VEC2);
809 }
810 
811 template <>
SpecializedSetup(bool)812 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2i, 0>(
813     bool /* valid */) {
814   SetupShaderForUniform(GL_INT_VEC2);
815 }
816 
817 template <>
SpecializedSetup(bool)818 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fvImmediate, 0>(
819     bool /* valid */) {
820   SetupShaderForUniform(GL_FLOAT_VEC2);
821 }
822 
823 template <>
SpecializedSetup(bool)824 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2ivImmediate, 0>(
825     bool /* valid */) {
826   SetupShaderForUniform(GL_INT_VEC2);
827 }
828 
829 template <>
SpecializedSetup(bool)830 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3f, 0>(
831     bool /* valid */) {
832   SetupShaderForUniform(GL_FLOAT_VEC3);
833 }
834 
835 template <>
SpecializedSetup(bool)836 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3i, 0>(
837     bool /* valid */) {
838   SetupShaderForUniform(GL_INT_VEC3);
839 }
840 
841 template <>
SpecializedSetup(bool)842 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fvImmediate, 0>(
843     bool /* valid */) {
844   SetupShaderForUniform(GL_FLOAT_VEC3);
845 }
846 
847 template <>
SpecializedSetup(bool)848 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3ivImmediate, 0>(
849     bool /* valid */) {
850   SetupShaderForUniform(GL_INT_VEC3);
851 }
852 
853 template <>
SpecializedSetup(bool)854 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4f, 0>(
855     bool /* valid */) {
856   SetupShaderForUniform(GL_FLOAT_VEC4);
857 }
858 
859 template <>
SpecializedSetup(bool)860 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(
861     bool /* valid */) {
862   SetupShaderForUniform(GL_FLOAT_MAT2);
863 }
864 
865 template <>
SpecializedSetup(bool)866 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterf, 0>(
867     bool /* valid */) {
868   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
869 }
870 
871 template <>
SpecializedSetup(bool)872 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteri, 0>(
873     bool /* valid */) {
874   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
875 }
876 
877 template <>
SpecializedSetup(bool)878 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfvImmediate, 0>(
879     bool /* valid */) {
880   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
881 }
882 
883 template <>
SpecializedSetup(bool)884 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
885     bool /* valid */) {
886   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
887 }
888 
889 template <>
SpecializedSetup(bool valid)890 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribiv, 0>(
891     bool valid) {
892   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
893   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
894   if (valid) {
895     EXPECT_CALL(*gl_, GetError())
896         .WillOnce(Return(GL_NO_ERROR))
897         .WillOnce(Return(GL_NO_ERROR))
898         .RetiresOnSaturation();
899   }
900 }
901 
902 template <>
SpecializedSetup(bool valid)903 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribfv, 0>(
904     bool valid) {
905   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
906   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
907   if (valid) {
908     EXPECT_CALL(*gl_, GetError())
909         .WillOnce(Return(GL_NO_ERROR))
910         .WillOnce(Return(GL_NO_ERROR))
911         .RetiresOnSaturation();
912   }
913 }
914 
915 template <>
SpecializedSetup(bool valid)916 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribIiv, 0>(
917     bool valid) {
918   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
919   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
920   if (valid) {
921     EXPECT_CALL(*gl_, GetError())
922         .WillOnce(Return(GL_NO_ERROR))
923         .WillOnce(Return(GL_NO_ERROR))
924         .RetiresOnSaturation();
925   }
926 }
927 
928 template <>
SpecializedSetup(bool valid)929 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribIuiv, 0>(
930     bool valid) {
931   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
932   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
933   if (valid) {
934     EXPECT_CALL(*gl_, GetError())
935         .WillOnce(Return(GL_NO_ERROR))
936         .WillOnce(Return(GL_NO_ERROR))
937         .RetiresOnSaturation();
938   }
939 }
940 
941 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h"
942 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT)943 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT) {
944   TestAcceptedUniform(GL_INT, UniformApiType::kUniform1i, false);
945 }
946 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT_VEC2)947 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC2) {
948   TestAcceptedUniform(GL_INT_VEC2, UniformApiType::kUniform2i, false);
949 }
950 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT_VEC3)951 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC3) {
952   TestAcceptedUniform(GL_INT_VEC3, UniformApiType::kUniform3i, false);
953 }
954 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT_VEC4)955 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC4) {
956   TestAcceptedUniform(GL_INT_VEC4, UniformApiType::kUniform4i, false);
957 }
958 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL)959 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL) {
960   TestAcceptedUniform(
961       GL_BOOL, UniformApiType::kUniform1i | UniformApiType::kUniform1f, false);
962 }
963 
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL)964 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL) {
965   TestAcceptedUniform(GL_BOOL,
966                       UniformApiType::kUniform1i | UniformApiType::kUniform1f |
967                           UniformApiType::kUniform1ui,
968                       true);
969 }
970 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL_VEC2)971 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC2) {
972   TestAcceptedUniform(GL_BOOL_VEC2,
973                       UniformApiType::kUniform2i | UniformApiType::kUniform2f,
974                       false);
975 }
976 
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL_VEC2)977 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL_VEC2) {
978   TestAcceptedUniform(GL_BOOL_VEC2,
979                       UniformApiType::kUniform2i | UniformApiType::kUniform2f |
980                           UniformApiType::kUniform2ui,
981                       true);
982 }
983 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL_VEC3)984 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC3) {
985   TestAcceptedUniform(GL_BOOL_VEC3,
986                       UniformApiType::kUniform3i | UniformApiType::kUniform3f,
987                       false);
988 }
989 
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL_VEC3)990 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL_VEC3) {
991   TestAcceptedUniform(GL_BOOL_VEC3,
992                       UniformApiType::kUniform3i | UniformApiType::kUniform3f |
993                           UniformApiType::kUniform3ui,
994                       true);
995 }
996 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL_VEC4)997 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC4) {
998   TestAcceptedUniform(GL_BOOL_VEC4,
999                       UniformApiType::kUniform4i | UniformApiType::kUniform4f,
1000                       false);
1001 }
1002 
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL_VEC4)1003 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL_VEC4) {
1004   TestAcceptedUniform(GL_BOOL_VEC4,
1005                       UniformApiType::kUniform4i | UniformApiType::kUniform4f |
1006                           UniformApiType::kUniform4ui,
1007                       true);
1008 }
1009 
TEST_P(GLES2DecoderTest2,AcceptsUniformTypeFLOAT)1010 TEST_P(GLES2DecoderTest2, AcceptsUniformTypeFLOAT) {
1011   TestAcceptedUniform(GL_FLOAT, UniformApiType::kUniform1f, false);
1012 }
1013 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_VEC2)1014 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC2) {
1015   TestAcceptedUniform(GL_FLOAT_VEC2, UniformApiType::kUniform2f, false);
1016 }
1017 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_VEC3)1018 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC3) {
1019   TestAcceptedUniform(GL_FLOAT_VEC3, UniformApiType::kUniform3f, false);
1020 }
1021 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_VEC4)1022 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC4) {
1023   TestAcceptedUniform(GL_FLOAT_VEC4, UniformApiType::kUniform4f, false);
1024 }
1025 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_MAT2)1026 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2) {
1027   TestAcceptedUniform(GL_FLOAT_MAT2, UniformApiType::kUniformMatrix2f, false);
1028 }
1029 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_MAT3)1030 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3) {
1031   TestAcceptedUniform(GL_FLOAT_MAT3, UniformApiType::kUniformMatrix3f, false);
1032 }
1033 
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_MAT4)1034 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) {
1035   TestAcceptedUniform(GL_FLOAT_MAT4, UniformApiType::kUniformMatrix4f, false);
1036 }
1037 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT)1038 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT) {
1039   TestAcceptedUniform(GL_UNSIGNED_INT, UniformApiType::kUniform1ui, true);
1040 }
1041 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT_VEC2)1042 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT_VEC2) {
1043   TestAcceptedUniform(GL_UNSIGNED_INT_VEC2, UniformApiType::kUniform2ui, true);
1044 }
1045 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT_VEC3)1046 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT_VEC3) {
1047   TestAcceptedUniform(GL_UNSIGNED_INT_VEC3, UniformApiType::kUniform3ui, true);
1048 }
1049 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT_VEC4)1050 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT_VEC4) {
1051   TestAcceptedUniform(GL_UNSIGNED_INT_VEC4, UniformApiType::kUniform4ui, true);
1052 }
1053 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT2x3)1054 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2x3) {
1055   TestAcceptedUniform(GL_FLOAT_MAT2x3, UniformApiType::kUniformMatrix2x3f,
1056                       true);
1057 }
1058 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT2x4)1059 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2x4) {
1060   TestAcceptedUniform(GL_FLOAT_MAT2x4, UniformApiType::kUniformMatrix2x4f,
1061                       true);
1062 }
1063 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT3x2)1064 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3x2) {
1065   TestAcceptedUniform(GL_FLOAT_MAT3x2, UniformApiType::kUniformMatrix3x2f,
1066                       true);
1067 }
1068 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT3x4)1069 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3x4) {
1070   TestAcceptedUniform(GL_FLOAT_MAT3x4, UniformApiType::kUniformMatrix3x4f,
1071                       true);
1072 }
1073 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT4x2)1074 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4x2) {
1075   TestAcceptedUniform(GL_FLOAT_MAT4x2, UniformApiType::kUniformMatrix4x2f,
1076                       true);
1077 }
1078 
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT4x3)1079 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4x3) {
1080   TestAcceptedUniform(GL_FLOAT_MAT4x3, UniformApiType::kUniformMatrix4x3f,
1081                       true);
1082 }
1083 
1084 }  // namespace gles2
1085 }  // namespace gpu
1086