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::GetProgramiv, 0>(bool valid) {
695 if (valid) {
696 // GetProgramiv calls ClearGLError then GetError to make sure
697 // it actually got a value so it can report correctly to the client.
698 EXPECT_CALL(*gl_, GetError())
699 .WillOnce(Return(GL_NO_ERROR))
700 .RetiresOnSaturation();
701 EXPECT_CALL(*gl_, GetError())
702 .WillOnce(Return(GL_NO_ERROR))
703 .RetiresOnSaturation();
704 }
705 }
706
707 template <>
SpecializedSetup(bool valid)708 void GLES2DecoderTestBase::SpecializedSetup<cmds::RenderbufferStorage, 0>(
709 bool valid) {
710 DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
711 kServiceRenderbufferId);
712 if (valid) {
713 EnsureRenderbufferBound(false);
714 EXPECT_CALL(*gl_, GetError())
715 .WillOnce(Return(GL_NO_ERROR))
716 .RetiresOnSaturation();
717 EXPECT_CALL(*gl_,
718 RenderbufferStorageEXT(GL_RENDERBUFFER, _, 3, 4))
719 .Times(1)
720 .RetiresOnSaturation();
721 EXPECT_CALL(*gl_, GetError())
722 .WillOnce(Return(GL_NO_ERROR))
723 .RetiresOnSaturation();
724 }
725 }
726
727 template <>
SpecializedSetup(bool valid)728 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXTImmediate, 0>(
729 bool valid) {
730 if (!valid) {
731 // Make the client_query_id_ so that trying to make it again
732 // will fail.
733 cmds::GenQueriesEXTImmediate& cmd =
734 *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
735 cmd.Init(1, &client_query_id_);
736 EXPECT_EQ(error::kNoError,
737 ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
738 }
739 }
740
741 template <>
SpecializedSetup(bool valid)742 void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXTImmediate, 0>(
743 bool valid) {
744 if (valid) {
745 // Make the client_query_id_ so that trying to delete it will succeed.
746 cmds::GenQueriesEXTImmediate& cmd =
747 *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
748 cmd.Init(1, &client_query_id_);
749 EXPECT_EQ(error::kNoError,
750 ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
751 }
752 }
753
754 template <>
SpecializedSetup(bool)755 void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(
756 bool /* valid */) {
757 const GLuint kClientVertexShaderId = 5001;
758 const GLuint kServiceVertexShaderId = 6001;
759 const GLuint kClientFragmentShaderId = 5002;
760 const GLuint kServiceFragmentShaderId = 6002;
761 DoCreateShader(
762 GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId);
763 DoCreateShader(
764 GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId);
765
766 TestHelper::SetShaderStates(
767 gl_.get(), GetShader(kClientVertexShaderId), true);
768 TestHelper::SetShaderStates(
769 gl_.get(), GetShader(kClientFragmentShaderId), true);
770
771 InSequence dummy;
772 EXPECT_CALL(*gl_,
773 AttachShader(kServiceProgramId, kServiceVertexShaderId))
774 .Times(1)
775 .RetiresOnSaturation();
776 EXPECT_CALL(*gl_,
777 AttachShader(kServiceProgramId, kServiceFragmentShaderId))
778 .Times(1)
779 .RetiresOnSaturation();
780 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
781 .WillOnce(SetArgPointee<2>(1));
782 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _))
783 .WillOnce(SetArgPointee<2>(0))
784 .RetiresOnSaturation();
785 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTES, _))
786 .WillOnce(SetArgPointee<2>(0));
787 EXPECT_CALL(
788 *gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
789 .WillOnce(SetArgPointee<2>(0));
790 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
791 .WillOnce(SetArgPointee<2>(0));
792
793 cmds::AttachShader attach_cmd;
794 attach_cmd.Init(client_program_id_, kClientVertexShaderId);
795 EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
796
797 attach_cmd.Init(client_program_id_, kClientFragmentShaderId);
798 EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
799 }
800
801 template <>
SpecializedSetup(bool)802 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1f, 0>(
803 bool /* valid */) {
804 SetupShaderForUniform(GL_FLOAT);
805 }
806
807 template <>
SpecializedSetup(bool)808 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fvImmediate, 0>(
809 bool /* valid */) {
810 SetupShaderForUniform(GL_FLOAT);
811 }
812
813 template <>
SpecializedSetup(bool)814 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1ivImmediate, 0>(
815 bool /* valid */) {
816 SetupShaderForUniform(GL_INT);
817 }
818
819 template <>
SpecializedSetup(bool)820 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2f, 0>(
821 bool /* valid */) {
822 SetupShaderForUniform(GL_FLOAT_VEC2);
823 }
824
825 template <>
SpecializedSetup(bool)826 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2i, 0>(
827 bool /* valid */) {
828 SetupShaderForUniform(GL_INT_VEC2);
829 }
830
831 template <>
SpecializedSetup(bool)832 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fvImmediate, 0>(
833 bool /* valid */) {
834 SetupShaderForUniform(GL_FLOAT_VEC2);
835 }
836
837 template <>
SpecializedSetup(bool)838 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2ivImmediate, 0>(
839 bool /* valid */) {
840 SetupShaderForUniform(GL_INT_VEC2);
841 }
842
843 template <>
SpecializedSetup(bool)844 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3f, 0>(
845 bool /* valid */) {
846 SetupShaderForUniform(GL_FLOAT_VEC3);
847 }
848
849 template <>
SpecializedSetup(bool)850 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3i, 0>(
851 bool /* valid */) {
852 SetupShaderForUniform(GL_INT_VEC3);
853 }
854
855 template <>
SpecializedSetup(bool)856 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fvImmediate, 0>(
857 bool /* valid */) {
858 SetupShaderForUniform(GL_FLOAT_VEC3);
859 }
860
861 template <>
SpecializedSetup(bool)862 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3ivImmediate, 0>(
863 bool /* valid */) {
864 SetupShaderForUniform(GL_INT_VEC3);
865 }
866
867 template <>
SpecializedSetup(bool)868 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(
869 bool /* valid */) {
870 SetupShaderForUniform(GL_FLOAT_MAT2);
871 }
872
873 template <>
SpecializedSetup(bool)874 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterf, 0>(
875 bool /* valid */) {
876 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
877 }
878
879 template <>
SpecializedSetup(bool)880 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteri, 0>(
881 bool /* valid */) {
882 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
883 }
884
885 template <>
SpecializedSetup(bool)886 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfvImmediate, 0>(
887 bool /* valid */) {
888 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
889 }
890
891 template <>
SpecializedSetup(bool)892 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
893 bool /* valid */) {
894 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
895 }
896
897 template <>
SpecializedSetup(bool valid)898 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribiv, 0>(
899 bool valid) {
900 DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
901 DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
902 if (valid) {
903 EXPECT_CALL(*gl_, GetError())
904 .WillOnce(Return(GL_NO_ERROR))
905 .WillOnce(Return(GL_NO_ERROR))
906 .RetiresOnSaturation();
907 }
908 }
909
910 template <>
SpecializedSetup(bool valid)911 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribfv, 0>(
912 bool valid) {
913 DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
914 DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
915 if (valid) {
916 EXPECT_CALL(*gl_, GetError())
917 .WillOnce(Return(GL_NO_ERROR))
918 .WillOnce(Return(GL_NO_ERROR))
919 .RetiresOnSaturation();
920 }
921 }
922
923 template <>
SpecializedSetup(bool valid)924 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribIiv, 0>(
925 bool valid) {
926 DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
927 DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
928 if (valid) {
929 EXPECT_CALL(*gl_, GetError())
930 .WillOnce(Return(GL_NO_ERROR))
931 .WillOnce(Return(GL_NO_ERROR))
932 .RetiresOnSaturation();
933 }
934 }
935
936 template <>
SpecializedSetup(bool valid)937 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribIuiv, 0>(
938 bool valid) {
939 DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
940 DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
941 if (valid) {
942 EXPECT_CALL(*gl_, GetError())
943 .WillOnce(Return(GL_NO_ERROR))
944 .WillOnce(Return(GL_NO_ERROR))
945 .RetiresOnSaturation();
946 }
947 }
948
949 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h"
950
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT)951 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT) {
952 TestAcceptedUniform(GL_INT, UniformApiType::kUniform1i, false);
953 }
954
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT_VEC2)955 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC2) {
956 TestAcceptedUniform(GL_INT_VEC2, UniformApiType::kUniform2i, false);
957 }
958
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT_VEC3)959 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC3) {
960 TestAcceptedUniform(GL_INT_VEC3, UniformApiType::kUniform3i, false);
961 }
962
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_INT_VEC4)963 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC4) {
964 TestAcceptedUniform(GL_INT_VEC4, UniformApiType::kUniform4i, false);
965 }
966
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL)967 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL) {
968 TestAcceptedUniform(
969 GL_BOOL, UniformApiType::kUniform1i | UniformApiType::kUniform1f, false);
970 }
971
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL)972 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL) {
973 TestAcceptedUniform(GL_BOOL,
974 UniformApiType::kUniform1i | UniformApiType::kUniform1f |
975 UniformApiType::kUniform1ui,
976 true);
977 }
978
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL_VEC2)979 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC2) {
980 TestAcceptedUniform(GL_BOOL_VEC2,
981 UniformApiType::kUniform2i | UniformApiType::kUniform2f,
982 false);
983 }
984
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL_VEC2)985 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL_VEC2) {
986 TestAcceptedUniform(GL_BOOL_VEC2,
987 UniformApiType::kUniform2i | UniformApiType::kUniform2f |
988 UniformApiType::kUniform2ui,
989 true);
990 }
991
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL_VEC3)992 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC3) {
993 TestAcceptedUniform(GL_BOOL_VEC3,
994 UniformApiType::kUniform3i | UniformApiType::kUniform3f,
995 false);
996 }
997
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL_VEC3)998 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL_VEC3) {
999 TestAcceptedUniform(GL_BOOL_VEC3,
1000 UniformApiType::kUniform3i | UniformApiType::kUniform3f |
1001 UniformApiType::kUniform3ui,
1002 true);
1003 }
1004
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_BOOL_VEC4)1005 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC4) {
1006 TestAcceptedUniform(GL_BOOL_VEC4,
1007 UniformApiType::kUniform4i | UniformApiType::kUniform4f,
1008 false);
1009 }
1010
TEST_P(GLES3DecoderTest2,AcceptsUniformES3_GL_BOOL_VEC4)1011 TEST_P(GLES3DecoderTest2, AcceptsUniformES3_GL_BOOL_VEC4) {
1012 TestAcceptedUniform(GL_BOOL_VEC4,
1013 UniformApiType::kUniform4i | UniformApiType::kUniform4f |
1014 UniformApiType::kUniform4ui,
1015 true);
1016 }
1017
TEST_P(GLES2DecoderTest2,AcceptsUniformTypeFLOAT)1018 TEST_P(GLES2DecoderTest2, AcceptsUniformTypeFLOAT) {
1019 TestAcceptedUniform(GL_FLOAT, UniformApiType::kUniform1f, false);
1020 }
1021
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_VEC2)1022 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC2) {
1023 TestAcceptedUniform(GL_FLOAT_VEC2, UniformApiType::kUniform2f, false);
1024 }
1025
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_VEC3)1026 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC3) {
1027 TestAcceptedUniform(GL_FLOAT_VEC3, UniformApiType::kUniform3f, false);
1028 }
1029
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_VEC4)1030 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC4) {
1031 TestAcceptedUniform(GL_FLOAT_VEC4, UniformApiType::kUniform4f, false);
1032 }
1033
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_MAT2)1034 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2) {
1035 TestAcceptedUniform(GL_FLOAT_MAT2, UniformApiType::kUniformMatrix2f, false);
1036 }
1037
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_MAT3)1038 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3) {
1039 TestAcceptedUniform(GL_FLOAT_MAT3, UniformApiType::kUniformMatrix3f, false);
1040 }
1041
TEST_P(GLES2DecoderTest2,AcceptsUniform_GL_FLOAT_MAT4)1042 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) {
1043 TestAcceptedUniform(GL_FLOAT_MAT4, UniformApiType::kUniformMatrix4f, false);
1044 }
1045
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT)1046 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT) {
1047 TestAcceptedUniform(GL_UNSIGNED_INT, UniformApiType::kUniform1ui, true);
1048 }
1049
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT_VEC2)1050 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT_VEC2) {
1051 TestAcceptedUniform(GL_UNSIGNED_INT_VEC2, UniformApiType::kUniform2ui, true);
1052 }
1053
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT_VEC3)1054 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT_VEC3) {
1055 TestAcceptedUniform(GL_UNSIGNED_INT_VEC3, UniformApiType::kUniform3ui, true);
1056 }
1057
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_UNSIGNED_INT_VEC4)1058 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_UNSIGNED_INT_VEC4) {
1059 TestAcceptedUniform(GL_UNSIGNED_INT_VEC4, UniformApiType::kUniform4ui, true);
1060 }
1061
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT2x3)1062 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2x3) {
1063 TestAcceptedUniform(GL_FLOAT_MAT2x3, UniformApiType::kUniformMatrix2x3f,
1064 true);
1065 }
1066
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT2x4)1067 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2x4) {
1068 TestAcceptedUniform(GL_FLOAT_MAT2x4, UniformApiType::kUniformMatrix2x4f,
1069 true);
1070 }
1071
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT3x2)1072 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3x2) {
1073 TestAcceptedUniform(GL_FLOAT_MAT3x2, UniformApiType::kUniformMatrix3x2f,
1074 true);
1075 }
1076
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT3x4)1077 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3x4) {
1078 TestAcceptedUniform(GL_FLOAT_MAT3x4, UniformApiType::kUniformMatrix3x4f,
1079 true);
1080 }
1081
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT4x2)1082 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4x2) {
1083 TestAcceptedUniform(GL_FLOAT_MAT4x2, UniformApiType::kUniformMatrix4x2f,
1084 true);
1085 }
1086
TEST_P(GLES3DecoderTest2,AcceptsUniform_GL_FLOAT_MAT4x3)1087 TEST_P(GLES3DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4x3) {
1088 TestAcceptedUniform(GL_FLOAT_MAT4x3, UniformApiType::kUniformMatrix4x3f,
1089 true);
1090 }
1091
1092 } // namespace gles2
1093 } // namespace gpu
1094