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