gles2_cmd_decoder_unittest_2_autogen.h revision 4ad1aa43a48567659193a298fad74f55e00b3dd9 
1// Copyright 2014 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// This file is auto-generated from
6// gpu/command_buffer/build_gles2_cmd_buffer.py
7// It's formatted by clang-format using chromium coding style:
8//    clang-format -i -style=chromium filename
9// DO NOT EDIT!
10
11// It is included by gles2_cmd_decoder_unittest_2.cc
12#ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
13#define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
14
15TEST_F(GLES2DecoderTest2, IsRenderbufferValidArgs) {
16  SpecializedSetup<cmds::IsRenderbuffer, 0>(true);
17  cmds::IsRenderbuffer cmd;
18  cmd.Init(client_renderbuffer_id_, shared_memory_id_, shared_memory_offset_);
19  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
20  EXPECT_EQ(GL_NO_ERROR, GetGLError());
21}
22
23TEST_F(GLES2DecoderTest2, IsRenderbufferInvalidArgsBadSharedMemoryId) {
24  SpecializedSetup<cmds::IsRenderbuffer, 0>(false);
25  cmds::IsRenderbuffer cmd;
26  cmd.Init(
27      client_renderbuffer_id_, kInvalidSharedMemoryId, shared_memory_offset_);
28  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
29  cmd.Init(
30      client_renderbuffer_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
31  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
32}
33
34TEST_F(GLES2DecoderTest2, IsShaderValidArgs) {
35  SpecializedSetup<cmds::IsShader, 0>(true);
36  cmds::IsShader cmd;
37  cmd.Init(client_shader_id_, shared_memory_id_, shared_memory_offset_);
38  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
39  EXPECT_EQ(GL_NO_ERROR, GetGLError());
40}
41
42TEST_F(GLES2DecoderTest2, IsShaderInvalidArgsBadSharedMemoryId) {
43  SpecializedSetup<cmds::IsShader, 0>(false);
44  cmds::IsShader cmd;
45  cmd.Init(client_shader_id_, kInvalidSharedMemoryId, shared_memory_offset_);
46  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
47  cmd.Init(client_shader_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
48  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
49}
50
51TEST_F(GLES2DecoderTest2, IsTextureValidArgs) {
52  SpecializedSetup<cmds::IsTexture, 0>(true);
53  cmds::IsTexture cmd;
54  cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
55  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
56  EXPECT_EQ(GL_NO_ERROR, GetGLError());
57}
58
59TEST_F(GLES2DecoderTest2, IsTextureInvalidArgsBadSharedMemoryId) {
60  SpecializedSetup<cmds::IsTexture, 0>(false);
61  cmds::IsTexture cmd;
62  cmd.Init(client_texture_id_, kInvalidSharedMemoryId, shared_memory_offset_);
63  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
64  cmd.Init(client_texture_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
65  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
66}
67
68TEST_F(GLES2DecoderTest2, LineWidthValidArgs) {
69  EXPECT_CALL(*gl_, LineWidth(0.5f));
70  SpecializedSetup<cmds::LineWidth, 0>(true);
71  cmds::LineWidth cmd;
72  cmd.Init(0.5f);
73  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
74  EXPECT_EQ(GL_NO_ERROR, GetGLError());
75}
76
77TEST_F(GLES2DecoderTest2, LineWidthInvalidValue0_0) {
78  SpecializedSetup<cmds::LineWidth, 0>(false);
79  cmds::LineWidth cmd;
80  cmd.Init(0.0f);
81  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
82  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
83}
84
85TEST_F(GLES2DecoderTest2, LinkProgramValidArgs) {
86  EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId));
87  SpecializedSetup<cmds::LinkProgram, 0>(true);
88  cmds::LinkProgram cmd;
89  cmd.Init(client_program_id_);
90  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
91  EXPECT_EQ(GL_NO_ERROR, GetGLError());
92}
93// TODO(gman): PixelStorei
94
95TEST_F(GLES2DecoderTest2, PolygonOffsetValidArgs) {
96  EXPECT_CALL(*gl_, PolygonOffset(1, 2));
97  SpecializedSetup<cmds::PolygonOffset, 0>(true);
98  cmds::PolygonOffset cmd;
99  cmd.Init(1, 2);
100  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
101  EXPECT_EQ(GL_NO_ERROR, GetGLError());
102}
103// TODO(gman): ReadPixels
104
105// TODO(gman): ReleaseShaderCompiler
106
107TEST_F(GLES2DecoderTest2, RenderbufferStorageValidArgs) {
108  SpecializedSetup<cmds::RenderbufferStorage, 0>(true);
109  cmds::RenderbufferStorage cmd;
110  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, 4);
111  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
112  EXPECT_EQ(GL_NO_ERROR, GetGLError());
113}
114
115TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs0_0) {
116  EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
117  SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
118  cmds::RenderbufferStorage cmd;
119  cmd.Init(GL_FRAMEBUFFER, GL_RGBA4, 3, 4);
120  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
121  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
122}
123
124TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs2_0) {
125  EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
126  SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
127  cmds::RenderbufferStorage cmd;
128  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, -1, 4);
129  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
130  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
131}
132
133TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs3_0) {
134  EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
135  SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
136  cmds::RenderbufferStorage cmd;
137  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, -1);
138  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
139  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
140}
141
142TEST_F(GLES2DecoderTest2, SampleCoverageValidArgs) {
143  EXPECT_CALL(*gl_, SampleCoverage(1, true));
144  SpecializedSetup<cmds::SampleCoverage, 0>(true);
145  cmds::SampleCoverage cmd;
146  cmd.Init(1, true);
147  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
148  EXPECT_EQ(GL_NO_ERROR, GetGLError());
149}
150
151TEST_F(GLES2DecoderTest2, ScissorValidArgs) {
152  EXPECT_CALL(*gl_, Scissor(1, 2, 3, 4));
153  SpecializedSetup<cmds::Scissor, 0>(true);
154  cmds::Scissor cmd;
155  cmd.Init(1, 2, 3, 4);
156  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
157  EXPECT_EQ(GL_NO_ERROR, GetGLError());
158}
159
160TEST_F(GLES2DecoderTest2, ScissorInvalidArgs2_0) {
161  EXPECT_CALL(*gl_, Scissor(_, _, _, _)).Times(0);
162  SpecializedSetup<cmds::Scissor, 0>(false);
163  cmds::Scissor cmd;
164  cmd.Init(1, 2, -1, 4);
165  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
166  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
167}
168
169TEST_F(GLES2DecoderTest2, ScissorInvalidArgs3_0) {
170  EXPECT_CALL(*gl_, Scissor(_, _, _, _)).Times(0);
171  SpecializedSetup<cmds::Scissor, 0>(false);
172  cmds::Scissor cmd;
173  cmd.Init(1, 2, 3, -1);
174  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
175  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
176}
177// TODO(gman): ShaderBinary
178
179// TODO(gman): ShaderSource
180
181// TODO(gman): ShaderSourceBucket
182
183TEST_F(GLES2DecoderTest2, StencilFuncValidArgs) {
184  EXPECT_CALL(*gl_, StencilFunc(GL_NEVER, 2, 3));
185  SpecializedSetup<cmds::StencilFunc, 0>(true);
186  cmds::StencilFunc cmd;
187  cmd.Init(GL_NEVER, 2, 3);
188  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
189  EXPECT_EQ(GL_NO_ERROR, GetGLError());
190}
191
192TEST_F(GLES2DecoderTest2, StencilFuncSeparateValidArgs) {
193  EXPECT_CALL(*gl_, StencilFuncSeparate(GL_FRONT, GL_NEVER, 3, 4));
194  SpecializedSetup<cmds::StencilFuncSeparate, 0>(true);
195  cmds::StencilFuncSeparate cmd;
196  cmd.Init(GL_FRONT, GL_NEVER, 3, 4);
197  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
198  EXPECT_EQ(GL_NO_ERROR, GetGLError());
199}
200
201TEST_F(GLES2DecoderTest2, StencilMaskValidArgs) {
202  SpecializedSetup<cmds::StencilMask, 0>(true);
203  cmds::StencilMask cmd;
204  cmd.Init(1);
205  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
206  EXPECT_EQ(GL_NO_ERROR, GetGLError());
207}
208
209TEST_F(GLES2DecoderTest2, StencilMaskSeparateValidArgs) {
210  SpecializedSetup<cmds::StencilMaskSeparate, 0>(true);
211  cmds::StencilMaskSeparate cmd;
212  cmd.Init(GL_FRONT, 2);
213  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
214  EXPECT_EQ(GL_NO_ERROR, GetGLError());
215}
216
217TEST_F(GLES2DecoderTest2, StencilOpValidArgs) {
218  EXPECT_CALL(*gl_, StencilOp(GL_KEEP, GL_INCR, GL_KEEP));
219  SpecializedSetup<cmds::StencilOp, 0>(true);
220  cmds::StencilOp cmd;
221  cmd.Init(GL_KEEP, GL_INCR, GL_KEEP);
222  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
223  EXPECT_EQ(GL_NO_ERROR, GetGLError());
224}
225
226TEST_F(GLES2DecoderTest2, StencilOpSeparateValidArgs) {
227  EXPECT_CALL(*gl_, StencilOpSeparate(GL_FRONT, GL_INCR, GL_KEEP, GL_KEEP));
228  SpecializedSetup<cmds::StencilOpSeparate, 0>(true);
229  cmds::StencilOpSeparate cmd;
230  cmd.Init(GL_FRONT, GL_INCR, GL_KEEP, GL_KEEP);
231  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
232  EXPECT_EQ(GL_NO_ERROR, GetGLError());
233}
234// TODO(gman): TexImage2D
235
236TEST_F(GLES2DecoderTest2, TexParameterfValidArgs) {
237  EXPECT_CALL(*gl_,
238              TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
239  SpecializedSetup<cmds::TexParameterf, 0>(true);
240  cmds::TexParameterf cmd;
241  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
242  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
243  EXPECT_EQ(GL_NO_ERROR, GetGLError());
244}
245
246TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_0) {
247  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
248  SpecializedSetup<cmds::TexParameterf, 0>(false);
249  cmds::TexParameterf cmd;
250  cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
251  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
252  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
253}
254
255TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
256  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
257  SpecializedSetup<cmds::TexParameterf, 0>(false);
258  cmds::TexParameterf cmd;
259  cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
260  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
261  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
262}
263
264TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
265  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
266  SpecializedSetup<cmds::TexParameterf, 0>(false);
267  cmds::TexParameterf cmd;
268  cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_NEAREST);
269  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
270  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
271}
272
273TEST_F(GLES2DecoderTest2, TexParameterfvValidArgs) {
274  SpecializedSetup<cmds::TexParameterfv, 0>(true);
275  cmds::TexParameterfv cmd;
276  cmd.Init(GL_TEXTURE_2D,
277           GL_TEXTURE_MAG_FILTER,
278           shared_memory_id_,
279           shared_memory_offset_);
280  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
281  EXPECT_CALL(
282      *gl_,
283      TexParameterf(GL_TEXTURE_2D,
284                    GL_TEXTURE_MAG_FILTER,
285                    *reinterpret_cast<const GLfloat*>(shared_memory_address_)));
286  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
287  EXPECT_EQ(GL_NO_ERROR, GetGLError());
288}
289
290TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
291  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
292  SpecializedSetup<cmds::TexParameterfv, 0>(false);
293  cmds::TexParameterfv cmd;
294  cmd.Init(GL_TEXTURE_1D,
295           GL_TEXTURE_MAG_FILTER,
296           shared_memory_id_,
297           shared_memory_offset_);
298  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
299  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
300  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
301}
302
303TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
304  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
305  SpecializedSetup<cmds::TexParameterfv, 0>(false);
306  cmds::TexParameterfv cmd;
307  cmd.Init(GL_TEXTURE_3D,
308           GL_TEXTURE_MAG_FILTER,
309           shared_memory_id_,
310           shared_memory_offset_);
311  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
312  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
313  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
314}
315
316TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
317  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
318  SpecializedSetup<cmds::TexParameterfv, 0>(false);
319  cmds::TexParameterfv cmd;
320  cmd.Init(GL_TEXTURE_2D,
321           GL_GENERATE_MIPMAP,
322           shared_memory_id_,
323           shared_memory_offset_);
324  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
325  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
326  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
327}
328
329TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
330  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
331  SpecializedSetup<cmds::TexParameterfv, 0>(false);
332  cmds::TexParameterfv cmd;
333  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
334  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
335  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
336}
337
338TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_1) {
339  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
340  SpecializedSetup<cmds::TexParameterfv, 0>(false);
341  cmds::TexParameterfv cmd;
342  cmd.Init(GL_TEXTURE_2D,
343           GL_TEXTURE_MAG_FILTER,
344           shared_memory_id_,
345           kInvalidSharedMemoryOffset);
346  GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
347  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
348}
349
350TEST_F(GLES2DecoderTest2, TexParameterfvImmediateValidArgs) {
351  cmds::TexParameterfvImmediate& cmd =
352      *GetImmediateAs<cmds::TexParameterfvImmediate>();
353  SpecializedSetup<cmds::TexParameterfvImmediate, 0>(true);
354  GLfloat temp[1] = {GL_NEAREST, };
355  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &temp[0]);
356  EXPECT_CALL(
357      *gl_,
358      TexParameterf(GL_TEXTURE_2D,
359                    GL_TEXTURE_MAG_FILTER,
360                    *reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
361  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
362  EXPECT_EQ(GL_NO_ERROR, GetGLError());
363}
364
365TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_0) {
366  cmds::TexParameterfvImmediate& cmd =
367      *GetImmediateAs<cmds::TexParameterfvImmediate>();
368  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
369  SpecializedSetup<cmds::TexParameterfvImmediate, 0>(false);
370  GLfloat temp[1] = {GL_NEAREST, };
371  cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, &temp[0]);
372  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
373  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
374}
375
376TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
377  cmds::TexParameterfvImmediate& cmd =
378      *GetImmediateAs<cmds::TexParameterfvImmediate>();
379  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
380  SpecializedSetup<cmds::TexParameterfvImmediate, 0>(false);
381  GLfloat temp[1] = {GL_NEAREST, };
382  cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, &temp[0]);
383  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
384  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
385}
386
387TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs1_0) {
388  cmds::TexParameterfvImmediate& cmd =
389      *GetImmediateAs<cmds::TexParameterfvImmediate>();
390  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
391  SpecializedSetup<cmds::TexParameterfvImmediate, 0>(false);
392  GLfloat temp[1] = {GL_NEAREST, };
393  cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &temp[0]);
394  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
395  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
396}
397
398TEST_F(GLES2DecoderTest2, TexParameteriValidArgs) {
399  EXPECT_CALL(*gl_,
400              TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
401  SpecializedSetup<cmds::TexParameteri, 0>(true);
402  cmds::TexParameteri cmd;
403  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
404  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
405  EXPECT_EQ(GL_NO_ERROR, GetGLError());
406}
407
408TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs0_0) {
409  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
410  SpecializedSetup<cmds::TexParameteri, 0>(false);
411  cmds::TexParameteri cmd;
412  cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
413  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
414  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
415}
416
417TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs0_1) {
418  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
419  SpecializedSetup<cmds::TexParameteri, 0>(false);
420  cmds::TexParameteri cmd;
421  cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
422  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
423  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
424}
425
426TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
427  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
428  SpecializedSetup<cmds::TexParameteri, 0>(false);
429  cmds::TexParameteri cmd;
430  cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_NEAREST);
431  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
432  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
433}
434
435TEST_F(GLES2DecoderTest2, TexParameterivValidArgs) {
436  SpecializedSetup<cmds::TexParameteriv, 0>(true);
437  cmds::TexParameteriv cmd;
438  cmd.Init(GL_TEXTURE_2D,
439           GL_TEXTURE_MAG_FILTER,
440           shared_memory_id_,
441           shared_memory_offset_);
442  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
443  EXPECT_CALL(
444      *gl_,
445      TexParameteri(GL_TEXTURE_2D,
446                    GL_TEXTURE_MAG_FILTER,
447                    *reinterpret_cast<const GLint*>(shared_memory_address_)));
448  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
449  EXPECT_EQ(GL_NO_ERROR, GetGLError());
450}
451
452TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
453  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
454  SpecializedSetup<cmds::TexParameteriv, 0>(false);
455  cmds::TexParameteriv cmd;
456  cmd.Init(GL_TEXTURE_1D,
457           GL_TEXTURE_MAG_FILTER,
458           shared_memory_id_,
459           shared_memory_offset_);
460  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
461  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
462  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
463}
464
465TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
466  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
467  SpecializedSetup<cmds::TexParameteriv, 0>(false);
468  cmds::TexParameteriv cmd;
469  cmd.Init(GL_TEXTURE_3D,
470           GL_TEXTURE_MAG_FILTER,
471           shared_memory_id_,
472           shared_memory_offset_);
473  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
474  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
475  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
476}
477
478TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
479  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
480  SpecializedSetup<cmds::TexParameteriv, 0>(false);
481  cmds::TexParameteriv cmd;
482  cmd.Init(GL_TEXTURE_2D,
483           GL_GENERATE_MIPMAP,
484           shared_memory_id_,
485           shared_memory_offset_);
486  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
487  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
488  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
489}
490
491TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
492  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
493  SpecializedSetup<cmds::TexParameteriv, 0>(false);
494  cmds::TexParameteriv cmd;
495  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
496  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
497  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
498}
499
500TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_1) {
501  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
502  SpecializedSetup<cmds::TexParameteriv, 0>(false);
503  cmds::TexParameteriv cmd;
504  cmd.Init(GL_TEXTURE_2D,
505           GL_TEXTURE_MAG_FILTER,
506           shared_memory_id_,
507           kInvalidSharedMemoryOffset);
508  GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
509  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
510}
511
512TEST_F(GLES2DecoderTest2, TexParameterivImmediateValidArgs) {
513  cmds::TexParameterivImmediate& cmd =
514      *GetImmediateAs<cmds::TexParameterivImmediate>();
515  SpecializedSetup<cmds::TexParameterivImmediate, 0>(true);
516  GLint temp[1] = {GL_NEAREST, };
517  cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &temp[0]);
518  EXPECT_CALL(
519      *gl_,
520      TexParameteri(GL_TEXTURE_2D,
521                    GL_TEXTURE_MAG_FILTER,
522                    *reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
523  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
524  EXPECT_EQ(GL_NO_ERROR, GetGLError());
525}
526
527TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_0) {
528  cmds::TexParameterivImmediate& cmd =
529      *GetImmediateAs<cmds::TexParameterivImmediate>();
530  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
531  SpecializedSetup<cmds::TexParameterivImmediate, 0>(false);
532  GLint temp[1] = {GL_NEAREST, };
533  cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, &temp[0]);
534  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
535  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
536}
537
538TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
539  cmds::TexParameterivImmediate& cmd =
540      *GetImmediateAs<cmds::TexParameterivImmediate>();
541  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
542  SpecializedSetup<cmds::TexParameterivImmediate, 0>(false);
543  GLint temp[1] = {GL_NEAREST, };
544  cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, &temp[0]);
545  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
546  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
547}
548
549TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs1_0) {
550  cmds::TexParameterivImmediate& cmd =
551      *GetImmediateAs<cmds::TexParameterivImmediate>();
552  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
553  SpecializedSetup<cmds::TexParameterivImmediate, 0>(false);
554  GLint temp[1] = {GL_NEAREST, };
555  cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &temp[0]);
556  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
557  EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
558}
559// TODO(gman): TexSubImage2D
560
561TEST_F(GLES2DecoderTest2, Uniform1fValidArgs) {
562  EXPECT_CALL(*gl_, Uniform1fv(1, 1, _));
563  SpecializedSetup<cmds::Uniform1f, 0>(true);
564  cmds::Uniform1f cmd;
565  cmd.Init(1, 2);
566  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
567  EXPECT_EQ(GL_NO_ERROR, GetGLError());
568}
569
570TEST_F(GLES2DecoderTest2, Uniform1fvValidArgs) {
571  EXPECT_CALL(
572      *gl_,
573      Uniform1fv(
574          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
575  SpecializedSetup<cmds::Uniform1fv, 0>(true);
576  cmds::Uniform1fv cmd;
577  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
578  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
579  EXPECT_EQ(GL_NO_ERROR, GetGLError());
580}
581
582TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs1_0) {
583  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
584  SpecializedSetup<cmds::Uniform1fv, 0>(false);
585  cmds::Uniform1fv cmd;
586  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
587  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
588  EXPECT_EQ(GL_NO_ERROR, GetGLError());
589}
590
591TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs2_0) {
592  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
593  SpecializedSetup<cmds::Uniform1fv, 0>(false);
594  cmds::Uniform1fv cmd;
595  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
596  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
597}
598
599TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs2_1) {
600  EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
601  SpecializedSetup<cmds::Uniform1fv, 0>(false);
602  cmds::Uniform1fv cmd;
603  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
604  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
605}
606
607TEST_F(GLES2DecoderTest2, Uniform1fvValidArgsCountTooLarge) {
608  EXPECT_CALL(
609      *gl_,
610      Uniform1fv(
611          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
612  SpecializedSetup<cmds::Uniform1fv, 0>(true);
613  cmds::Uniform1fv cmd;
614  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
615           5,
616           shared_memory_id_,
617           shared_memory_offset_);
618  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
619  EXPECT_EQ(GL_NO_ERROR, GetGLError());
620}
621
622TEST_F(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
623  cmds::Uniform1fvImmediate& cmd = *GetImmediateAs<cmds::Uniform1fvImmediate>();
624  EXPECT_CALL(
625      *gl_,
626      Uniform1fv(1, 2, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
627  SpecializedSetup<cmds::Uniform1fvImmediate, 0>(true);
628  GLfloat temp[1 * 2] = {0, };
629  cmd.Init(1, 2, &temp[0]);
630  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
631  EXPECT_EQ(GL_NO_ERROR, GetGLError());
632}
633// TODO(gman): Uniform1i
634// TODO(gman): Uniform1iv
635// TODO(gman): Uniform1ivImmediate
636
637TEST_F(GLES2DecoderTest2, Uniform2fValidArgs) {
638  EXPECT_CALL(*gl_, Uniform2fv(1, 1, _));
639  SpecializedSetup<cmds::Uniform2f, 0>(true);
640  cmds::Uniform2f cmd;
641  cmd.Init(1, 2, 3);
642  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
643  EXPECT_EQ(GL_NO_ERROR, GetGLError());
644}
645
646TEST_F(GLES2DecoderTest2, Uniform2fvValidArgs) {
647  EXPECT_CALL(
648      *gl_,
649      Uniform2fv(
650          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
651  SpecializedSetup<cmds::Uniform2fv, 0>(true);
652  cmds::Uniform2fv cmd;
653  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
654  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
655  EXPECT_EQ(GL_NO_ERROR, GetGLError());
656}
657
658TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs1_0) {
659  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
660  SpecializedSetup<cmds::Uniform2fv, 0>(false);
661  cmds::Uniform2fv cmd;
662  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
663  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
664  EXPECT_EQ(GL_NO_ERROR, GetGLError());
665}
666
667TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs2_0) {
668  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
669  SpecializedSetup<cmds::Uniform2fv, 0>(false);
670  cmds::Uniform2fv cmd;
671  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
672  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
673}
674
675TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs2_1) {
676  EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
677  SpecializedSetup<cmds::Uniform2fv, 0>(false);
678  cmds::Uniform2fv cmd;
679  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
680  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
681}
682
683TEST_F(GLES2DecoderTest2, Uniform2fvValidArgsCountTooLarge) {
684  EXPECT_CALL(
685      *gl_,
686      Uniform2fv(
687          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
688  SpecializedSetup<cmds::Uniform2fv, 0>(true);
689  cmds::Uniform2fv cmd;
690  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
691           5,
692           shared_memory_id_,
693           shared_memory_offset_);
694  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
695  EXPECT_EQ(GL_NO_ERROR, GetGLError());
696}
697
698TEST_F(GLES2DecoderTest2, Uniform2fvImmediateValidArgs) {
699  cmds::Uniform2fvImmediate& cmd = *GetImmediateAs<cmds::Uniform2fvImmediate>();
700  EXPECT_CALL(
701      *gl_,
702      Uniform2fv(1, 2, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
703  SpecializedSetup<cmds::Uniform2fvImmediate, 0>(true);
704  GLfloat temp[2 * 2] = {0, };
705  cmd.Init(1, 2, &temp[0]);
706  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
707  EXPECT_EQ(GL_NO_ERROR, GetGLError());
708}
709
710TEST_F(GLES2DecoderTest2, Uniform2iValidArgs) {
711  EXPECT_CALL(*gl_, Uniform2iv(1, 1, _));
712  SpecializedSetup<cmds::Uniform2i, 0>(true);
713  cmds::Uniform2i cmd;
714  cmd.Init(1, 2, 3);
715  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
716  EXPECT_EQ(GL_NO_ERROR, GetGLError());
717}
718
719TEST_F(GLES2DecoderTest2, Uniform2ivValidArgs) {
720  EXPECT_CALL(
721      *gl_,
722      Uniform2iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
723  SpecializedSetup<cmds::Uniform2iv, 0>(true);
724  cmds::Uniform2iv cmd;
725  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
726  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
727  EXPECT_EQ(GL_NO_ERROR, GetGLError());
728}
729
730TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs1_0) {
731  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
732  SpecializedSetup<cmds::Uniform2iv, 0>(false);
733  cmds::Uniform2iv cmd;
734  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
735  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
736  EXPECT_EQ(GL_NO_ERROR, GetGLError());
737}
738
739TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs2_0) {
740  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
741  SpecializedSetup<cmds::Uniform2iv, 0>(false);
742  cmds::Uniform2iv cmd;
743  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
744  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
745}
746
747TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs2_1) {
748  EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
749  SpecializedSetup<cmds::Uniform2iv, 0>(false);
750  cmds::Uniform2iv cmd;
751  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
752  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
753}
754
755TEST_F(GLES2DecoderTest2, Uniform2ivValidArgsCountTooLarge) {
756  EXPECT_CALL(
757      *gl_,
758      Uniform2iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
759  SpecializedSetup<cmds::Uniform2iv, 0>(true);
760  cmds::Uniform2iv cmd;
761  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
762           5,
763           shared_memory_id_,
764           shared_memory_offset_);
765  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
766  EXPECT_EQ(GL_NO_ERROR, GetGLError());
767}
768
769TEST_F(GLES2DecoderTest2, Uniform2ivImmediateValidArgs) {
770  cmds::Uniform2ivImmediate& cmd = *GetImmediateAs<cmds::Uniform2ivImmediate>();
771  EXPECT_CALL(
772      *gl_,
773      Uniform2iv(1, 2, reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
774  SpecializedSetup<cmds::Uniform2ivImmediate, 0>(true);
775  GLint temp[2 * 2] = {0, };
776  cmd.Init(1, 2, &temp[0]);
777  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
778  EXPECT_EQ(GL_NO_ERROR, GetGLError());
779}
780
781TEST_F(GLES2DecoderTest2, Uniform3fValidArgs) {
782  EXPECT_CALL(*gl_, Uniform3fv(1, 1, _));
783  SpecializedSetup<cmds::Uniform3f, 0>(true);
784  cmds::Uniform3f cmd;
785  cmd.Init(1, 2, 3, 4);
786  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
787  EXPECT_EQ(GL_NO_ERROR, GetGLError());
788}
789
790TEST_F(GLES2DecoderTest2, Uniform3fvValidArgs) {
791  EXPECT_CALL(
792      *gl_,
793      Uniform3fv(
794          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
795  SpecializedSetup<cmds::Uniform3fv, 0>(true);
796  cmds::Uniform3fv cmd;
797  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
798  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
799  EXPECT_EQ(GL_NO_ERROR, GetGLError());
800}
801
802TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs1_0) {
803  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
804  SpecializedSetup<cmds::Uniform3fv, 0>(false);
805  cmds::Uniform3fv cmd;
806  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
807  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
808  EXPECT_EQ(GL_NO_ERROR, GetGLError());
809}
810
811TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs2_0) {
812  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
813  SpecializedSetup<cmds::Uniform3fv, 0>(false);
814  cmds::Uniform3fv cmd;
815  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
816  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
817}
818
819TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs2_1) {
820  EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
821  SpecializedSetup<cmds::Uniform3fv, 0>(false);
822  cmds::Uniform3fv cmd;
823  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
824  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
825}
826
827TEST_F(GLES2DecoderTest2, Uniform3fvValidArgsCountTooLarge) {
828  EXPECT_CALL(
829      *gl_,
830      Uniform3fv(
831          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
832  SpecializedSetup<cmds::Uniform3fv, 0>(true);
833  cmds::Uniform3fv cmd;
834  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
835           5,
836           shared_memory_id_,
837           shared_memory_offset_);
838  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
839  EXPECT_EQ(GL_NO_ERROR, GetGLError());
840}
841
842TEST_F(GLES2DecoderTest2, Uniform3fvImmediateValidArgs) {
843  cmds::Uniform3fvImmediate& cmd = *GetImmediateAs<cmds::Uniform3fvImmediate>();
844  EXPECT_CALL(
845      *gl_,
846      Uniform3fv(1, 2, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
847  SpecializedSetup<cmds::Uniform3fvImmediate, 0>(true);
848  GLfloat temp[3 * 2] = {0, };
849  cmd.Init(1, 2, &temp[0]);
850  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
851  EXPECT_EQ(GL_NO_ERROR, GetGLError());
852}
853
854TEST_F(GLES2DecoderTest2, Uniform3iValidArgs) {
855  EXPECT_CALL(*gl_, Uniform3iv(1, 1, _));
856  SpecializedSetup<cmds::Uniform3i, 0>(true);
857  cmds::Uniform3i cmd;
858  cmd.Init(1, 2, 3, 4);
859  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
860  EXPECT_EQ(GL_NO_ERROR, GetGLError());
861}
862
863TEST_F(GLES2DecoderTest2, Uniform3ivValidArgs) {
864  EXPECT_CALL(
865      *gl_,
866      Uniform3iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
867  SpecializedSetup<cmds::Uniform3iv, 0>(true);
868  cmds::Uniform3iv cmd;
869  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
870  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
871  EXPECT_EQ(GL_NO_ERROR, GetGLError());
872}
873
874TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs1_0) {
875  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
876  SpecializedSetup<cmds::Uniform3iv, 0>(false);
877  cmds::Uniform3iv cmd;
878  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
879  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
880  EXPECT_EQ(GL_NO_ERROR, GetGLError());
881}
882
883TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs2_0) {
884  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
885  SpecializedSetup<cmds::Uniform3iv, 0>(false);
886  cmds::Uniform3iv cmd;
887  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
888  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
889}
890
891TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs2_1) {
892  EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
893  SpecializedSetup<cmds::Uniform3iv, 0>(false);
894  cmds::Uniform3iv cmd;
895  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
896  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
897}
898
899TEST_F(GLES2DecoderTest2, Uniform3ivValidArgsCountTooLarge) {
900  EXPECT_CALL(
901      *gl_,
902      Uniform3iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
903  SpecializedSetup<cmds::Uniform3iv, 0>(true);
904  cmds::Uniform3iv cmd;
905  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
906           5,
907           shared_memory_id_,
908           shared_memory_offset_);
909  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
910  EXPECT_EQ(GL_NO_ERROR, GetGLError());
911}
912
913TEST_F(GLES2DecoderTest2, Uniform3ivImmediateValidArgs) {
914  cmds::Uniform3ivImmediate& cmd = *GetImmediateAs<cmds::Uniform3ivImmediate>();
915  EXPECT_CALL(
916      *gl_,
917      Uniform3iv(1, 2, reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
918  SpecializedSetup<cmds::Uniform3ivImmediate, 0>(true);
919  GLint temp[3 * 2] = {0, };
920  cmd.Init(1, 2, &temp[0]);
921  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
922  EXPECT_EQ(GL_NO_ERROR, GetGLError());
923}
924
925TEST_F(GLES2DecoderTest2, Uniform4fValidArgs) {
926  EXPECT_CALL(*gl_, Uniform4fv(1, 1, _));
927  SpecializedSetup<cmds::Uniform4f, 0>(true);
928  cmds::Uniform4f cmd;
929  cmd.Init(1, 2, 3, 4, 5);
930  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
931  EXPECT_EQ(GL_NO_ERROR, GetGLError());
932}
933
934TEST_F(GLES2DecoderTest2, Uniform4fvValidArgs) {
935  EXPECT_CALL(
936      *gl_,
937      Uniform4fv(
938          1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
939  SpecializedSetup<cmds::Uniform4fv, 0>(true);
940  cmds::Uniform4fv cmd;
941  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
942  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
943  EXPECT_EQ(GL_NO_ERROR, GetGLError());
944}
945
946TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs1_0) {
947  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
948  SpecializedSetup<cmds::Uniform4fv, 0>(false);
949  cmds::Uniform4fv cmd;
950  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
951  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
952  EXPECT_EQ(GL_NO_ERROR, GetGLError());
953}
954
955TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs2_0) {
956  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
957  SpecializedSetup<cmds::Uniform4fv, 0>(false);
958  cmds::Uniform4fv cmd;
959  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
960  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
961}
962
963TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs2_1) {
964  EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
965  SpecializedSetup<cmds::Uniform4fv, 0>(false);
966  cmds::Uniform4fv cmd;
967  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
968  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
969}
970
971TEST_F(GLES2DecoderTest2, Uniform4fvValidArgsCountTooLarge) {
972  EXPECT_CALL(
973      *gl_,
974      Uniform4fv(
975          3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
976  SpecializedSetup<cmds::Uniform4fv, 0>(true);
977  cmds::Uniform4fv cmd;
978  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
979           5,
980           shared_memory_id_,
981           shared_memory_offset_);
982  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
983  EXPECT_EQ(GL_NO_ERROR, GetGLError());
984}
985
986TEST_F(GLES2DecoderTest2, Uniform4fvImmediateValidArgs) {
987  cmds::Uniform4fvImmediate& cmd = *GetImmediateAs<cmds::Uniform4fvImmediate>();
988  EXPECT_CALL(
989      *gl_,
990      Uniform4fv(1, 2, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
991  SpecializedSetup<cmds::Uniform4fvImmediate, 0>(true);
992  GLfloat temp[4 * 2] = {0, };
993  cmd.Init(1, 2, &temp[0]);
994  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
995  EXPECT_EQ(GL_NO_ERROR, GetGLError());
996}
997
998TEST_F(GLES2DecoderTest2, Uniform4iValidArgs) {
999  EXPECT_CALL(*gl_, Uniform4iv(1, 1, _));
1000  SpecializedSetup<cmds::Uniform4i, 0>(true);
1001  cmds::Uniform4i cmd;
1002  cmd.Init(1, 2, 3, 4, 5);
1003  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1004  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1005}
1006
1007TEST_F(GLES2DecoderTest2, Uniform4ivValidArgs) {
1008  EXPECT_CALL(
1009      *gl_,
1010      Uniform4iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
1011  SpecializedSetup<cmds::Uniform4iv, 0>(true);
1012  cmds::Uniform4iv cmd;
1013  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
1014  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1015  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1016}
1017
1018TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs1_0) {
1019  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
1020  SpecializedSetup<cmds::Uniform4iv, 0>(false);
1021  cmds::Uniform4iv cmd;
1022  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
1023  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1024  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1025}
1026
1027TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs2_0) {
1028  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
1029  SpecializedSetup<cmds::Uniform4iv, 0>(false);
1030  cmds::Uniform4iv cmd;
1031  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
1032  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1033}
1034
1035TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs2_1) {
1036  EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
1037  SpecializedSetup<cmds::Uniform4iv, 0>(false);
1038  cmds::Uniform4iv cmd;
1039  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
1040  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1041}
1042
1043TEST_F(GLES2DecoderTest2, Uniform4ivValidArgsCountTooLarge) {
1044  EXPECT_CALL(
1045      *gl_,
1046      Uniform4iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
1047  SpecializedSetup<cmds::Uniform4iv, 0>(true);
1048  cmds::Uniform4iv cmd;
1049  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
1050           5,
1051           shared_memory_id_,
1052           shared_memory_offset_);
1053  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1054  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1055}
1056
1057TEST_F(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
1058  cmds::Uniform4ivImmediate& cmd = *GetImmediateAs<cmds::Uniform4ivImmediate>();
1059  EXPECT_CALL(
1060      *gl_,
1061      Uniform4iv(1, 2, reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
1062  SpecializedSetup<cmds::Uniform4ivImmediate, 0>(true);
1063  GLint temp[4 * 2] = {0, };
1064  cmd.Init(1, 2, &temp[0]);
1065  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1066  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1067}
1068
1069TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
1070  EXPECT_CALL(*gl_,
1071              UniformMatrix2fv(
1072                  1,
1073                  2,
1074                  false,
1075                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1076  SpecializedSetup<cmds::UniformMatrix2fv, 0>(true);
1077  cmds::UniformMatrix2fv cmd;
1078  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
1079  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1080  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1081}
1082
1083TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
1084  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
1085  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
1086  cmds::UniformMatrix2fv cmd;
1087  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
1088  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1089  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1090}
1091
1092TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs2_0) {
1093  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
1094  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
1095  cmds::UniformMatrix2fv cmd;
1096  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
1097  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1098  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1099}
1100
1101TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
1102  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
1103  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
1104  cmds::UniformMatrix2fv cmd;
1105  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
1106  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1107}
1108
1109TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_1) {
1110  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
1111  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
1112  cmds::UniformMatrix2fv cmd;
1113  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
1114  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1115}
1116
1117TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgsCountTooLarge) {
1118  EXPECT_CALL(*gl_,
1119              UniformMatrix2fv(
1120                  3,
1121                  3,
1122                  false,
1123                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1124  SpecializedSetup<cmds::UniformMatrix2fv, 0>(true);
1125  cmds::UniformMatrix2fv cmd;
1126  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
1127           5,
1128           false,
1129           shared_memory_id_,
1130           shared_memory_offset_);
1131  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1132  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1133}
1134
1135TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
1136  cmds::UniformMatrix2fvImmediate& cmd =
1137      *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
1138  EXPECT_CALL(
1139      *gl_,
1140      UniformMatrix2fv(
1141          1, 2, false, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
1142  SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(true);
1143  GLfloat temp[4 * 2] = {0, };
1144  cmd.Init(1, 2, false, &temp[0]);
1145  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1146  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1147}
1148
1149TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
1150  cmds::UniformMatrix2fvImmediate& cmd =
1151      *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
1152  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
1153  SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(false);
1154  GLfloat temp[4 * 2] = {0, };
1155  cmd.Init(1, 2, true, &temp[0]);
1156  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1157  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1158}
1159
1160TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
1161  EXPECT_CALL(*gl_,
1162              UniformMatrix3fv(
1163                  1,
1164                  2,
1165                  false,
1166                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1167  SpecializedSetup<cmds::UniformMatrix3fv, 0>(true);
1168  cmds::UniformMatrix3fv cmd;
1169  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
1170  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1171  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1172}
1173
1174TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
1175  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
1176  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
1177  cmds::UniformMatrix3fv cmd;
1178  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
1179  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1180  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1181}
1182
1183TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs2_0) {
1184  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
1185  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
1186  cmds::UniformMatrix3fv cmd;
1187  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
1188  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1189  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1190}
1191
1192TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
1193  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
1194  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
1195  cmds::UniformMatrix3fv cmd;
1196  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
1197  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1198}
1199
1200TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_1) {
1201  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
1202  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
1203  cmds::UniformMatrix3fv cmd;
1204  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
1205  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1206}
1207
1208TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgsCountTooLarge) {
1209  EXPECT_CALL(*gl_,
1210              UniformMatrix3fv(
1211                  3,
1212                  3,
1213                  false,
1214                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1215  SpecializedSetup<cmds::UniformMatrix3fv, 0>(true);
1216  cmds::UniformMatrix3fv cmd;
1217  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
1218           5,
1219           false,
1220           shared_memory_id_,
1221           shared_memory_offset_);
1222  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1223  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1224}
1225
1226TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
1227  cmds::UniformMatrix3fvImmediate& cmd =
1228      *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
1229  EXPECT_CALL(
1230      *gl_,
1231      UniformMatrix3fv(
1232          1, 2, false, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
1233  SpecializedSetup<cmds::UniformMatrix3fvImmediate, 0>(true);
1234  GLfloat temp[9 * 2] = {0, };
1235  cmd.Init(1, 2, false, &temp[0]);
1236  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1237  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1238}
1239
1240TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
1241  cmds::UniformMatrix3fvImmediate& cmd =
1242      *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
1243  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
1244  SpecializedSetup<cmds::UniformMatrix3fvImmediate, 0>(false);
1245  GLfloat temp[9 * 2] = {0, };
1246  cmd.Init(1, 2, true, &temp[0]);
1247  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1248  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1249}
1250
1251TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
1252  EXPECT_CALL(*gl_,
1253              UniformMatrix4fv(
1254                  1,
1255                  2,
1256                  false,
1257                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1258  SpecializedSetup<cmds::UniformMatrix4fv, 0>(true);
1259  cmds::UniformMatrix4fv cmd;
1260  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
1261  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1262  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1263}
1264
1265TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
1266  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
1267  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
1268  cmds::UniformMatrix4fv cmd;
1269  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
1270  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1271  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1272}
1273
1274TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs2_0) {
1275  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
1276  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
1277  cmds::UniformMatrix4fv cmd;
1278  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
1279  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1280  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1281}
1282
1283TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
1284  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
1285  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
1286  cmds::UniformMatrix4fv cmd;
1287  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
1288  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1289}
1290
1291TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_1) {
1292  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
1293  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
1294  cmds::UniformMatrix4fv cmd;
1295  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
1296  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1297}
1298
1299TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgsCountTooLarge) {
1300  EXPECT_CALL(*gl_,
1301              UniformMatrix4fv(
1302                  3,
1303                  3,
1304                  false,
1305                  reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1306  SpecializedSetup<cmds::UniformMatrix4fv, 0>(true);
1307  cmds::UniformMatrix4fv cmd;
1308  cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
1309           5,
1310           false,
1311           shared_memory_id_,
1312           shared_memory_offset_);
1313  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1314  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1315}
1316
1317TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
1318  cmds::UniformMatrix4fvImmediate& cmd =
1319      *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
1320  EXPECT_CALL(
1321      *gl_,
1322      UniformMatrix4fv(
1323          1, 2, false, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
1324  SpecializedSetup<cmds::UniformMatrix4fvImmediate, 0>(true);
1325  GLfloat temp[16 * 2] = {0, };
1326  cmd.Init(1, 2, false, &temp[0]);
1327  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1328  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1329}
1330
1331TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
1332  cmds::UniformMatrix4fvImmediate& cmd =
1333      *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
1334  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
1335  SpecializedSetup<cmds::UniformMatrix4fvImmediate, 0>(false);
1336  GLfloat temp[16 * 2] = {0, };
1337  cmd.Init(1, 2, true, &temp[0]);
1338  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1339  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1340}
1341
1342TEST_F(GLES2DecoderTest2, UseProgramValidArgs) {
1343  EXPECT_CALL(*gl_, UseProgram(kServiceProgramId));
1344  SpecializedSetup<cmds::UseProgram, 0>(true);
1345  cmds::UseProgram cmd;
1346  cmd.Init(client_program_id_);
1347  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1348  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1349}
1350
1351TEST_F(GLES2DecoderTest2, UseProgramInvalidArgs0_0) {
1352  EXPECT_CALL(*gl_, UseProgram(_)).Times(0);
1353  SpecializedSetup<cmds::UseProgram, 0>(false);
1354  cmds::UseProgram cmd;
1355  cmd.Init(kInvalidClientId);
1356  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1357  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1358}
1359
1360TEST_F(GLES2DecoderTest2, ValidateProgramValidArgs) {
1361  EXPECT_CALL(*gl_, ValidateProgram(kServiceProgramId));
1362  SpecializedSetup<cmds::ValidateProgram, 0>(true);
1363  cmds::ValidateProgram cmd;
1364  cmd.Init(client_program_id_);
1365  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1366  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1367}
1368
1369TEST_F(GLES2DecoderTest2, VertexAttrib1fValidArgs) {
1370  EXPECT_CALL(*gl_, VertexAttrib1f(1, 2));
1371  SpecializedSetup<cmds::VertexAttrib1f, 0>(true);
1372  cmds::VertexAttrib1f cmd;
1373  cmd.Init(1, 2);
1374  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1375  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1376}
1377
1378TEST_F(GLES2DecoderTest2, VertexAttrib1fvValidArgs) {
1379  SpecializedSetup<cmds::VertexAttrib1fv, 0>(true);
1380  cmds::VertexAttrib1fv cmd;
1381  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
1382  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1383  EXPECT_CALL(*gl_,
1384              VertexAttrib1fv(
1385                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1386  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1387  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1388}
1389
1390TEST_F(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_0) {
1391  EXPECT_CALL(*gl_, VertexAttrib1fv(_, _)).Times(0);
1392  SpecializedSetup<cmds::VertexAttrib1fv, 0>(false);
1393  cmds::VertexAttrib1fv cmd;
1394  cmd.Init(1, kInvalidSharedMemoryId, 0);
1395  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1396  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1397}
1398
1399TEST_F(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_1) {
1400  EXPECT_CALL(*gl_, VertexAttrib1fv(_, _)).Times(0);
1401  SpecializedSetup<cmds::VertexAttrib1fv, 0>(false);
1402  cmds::VertexAttrib1fv cmd;
1403  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
1404  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1405  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1406}
1407
1408TEST_F(GLES2DecoderTest2, VertexAttrib1fvImmediateValidArgs) {
1409  cmds::VertexAttrib1fvImmediate& cmd =
1410      *GetImmediateAs<cmds::VertexAttrib1fvImmediate>();
1411  SpecializedSetup<cmds::VertexAttrib1fvImmediate, 0>(true);
1412  GLfloat temp[1] = {0, };
1413  cmd.Init(1, &temp[0]);
1414  EXPECT_CALL(*gl_,
1415              VertexAttrib1fv(
1416                  1, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
1417  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1418  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1419}
1420
1421TEST_F(GLES2DecoderTest2, VertexAttrib2fValidArgs) {
1422  EXPECT_CALL(*gl_, VertexAttrib2f(1, 2, 3));
1423  SpecializedSetup<cmds::VertexAttrib2f, 0>(true);
1424  cmds::VertexAttrib2f cmd;
1425  cmd.Init(1, 2, 3);
1426  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1427  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1428}
1429
1430TEST_F(GLES2DecoderTest2, VertexAttrib2fvValidArgs) {
1431  SpecializedSetup<cmds::VertexAttrib2fv, 0>(true);
1432  cmds::VertexAttrib2fv cmd;
1433  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
1434  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1435  EXPECT_CALL(*gl_,
1436              VertexAttrib2fv(
1437                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1438  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1439  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1440}
1441
1442TEST_F(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_0) {
1443  EXPECT_CALL(*gl_, VertexAttrib2fv(_, _)).Times(0);
1444  SpecializedSetup<cmds::VertexAttrib2fv, 0>(false);
1445  cmds::VertexAttrib2fv cmd;
1446  cmd.Init(1, kInvalidSharedMemoryId, 0);
1447  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1448  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1449}
1450
1451TEST_F(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_1) {
1452  EXPECT_CALL(*gl_, VertexAttrib2fv(_, _)).Times(0);
1453  SpecializedSetup<cmds::VertexAttrib2fv, 0>(false);
1454  cmds::VertexAttrib2fv cmd;
1455  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
1456  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1457  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1458}
1459
1460TEST_F(GLES2DecoderTest2, VertexAttrib2fvImmediateValidArgs) {
1461  cmds::VertexAttrib2fvImmediate& cmd =
1462      *GetImmediateAs<cmds::VertexAttrib2fvImmediate>();
1463  SpecializedSetup<cmds::VertexAttrib2fvImmediate, 0>(true);
1464  GLfloat temp[2] = {0, };
1465  cmd.Init(1, &temp[0]);
1466  EXPECT_CALL(*gl_,
1467              VertexAttrib2fv(
1468                  1, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
1469  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1470  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1471}
1472
1473TEST_F(GLES2DecoderTest2, VertexAttrib3fValidArgs) {
1474  EXPECT_CALL(*gl_, VertexAttrib3f(1, 2, 3, 4));
1475  SpecializedSetup<cmds::VertexAttrib3f, 0>(true);
1476  cmds::VertexAttrib3f cmd;
1477  cmd.Init(1, 2, 3, 4);
1478  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1479  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1480}
1481
1482TEST_F(GLES2DecoderTest2, VertexAttrib3fvValidArgs) {
1483  SpecializedSetup<cmds::VertexAttrib3fv, 0>(true);
1484  cmds::VertexAttrib3fv cmd;
1485  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
1486  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1487  EXPECT_CALL(*gl_,
1488              VertexAttrib3fv(
1489                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1490  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1491  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1492}
1493
1494TEST_F(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_0) {
1495  EXPECT_CALL(*gl_, VertexAttrib3fv(_, _)).Times(0);
1496  SpecializedSetup<cmds::VertexAttrib3fv, 0>(false);
1497  cmds::VertexAttrib3fv cmd;
1498  cmd.Init(1, kInvalidSharedMemoryId, 0);
1499  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1500  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1501}
1502
1503TEST_F(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_1) {
1504  EXPECT_CALL(*gl_, VertexAttrib3fv(_, _)).Times(0);
1505  SpecializedSetup<cmds::VertexAttrib3fv, 0>(false);
1506  cmds::VertexAttrib3fv cmd;
1507  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
1508  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1509  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1510}
1511
1512TEST_F(GLES2DecoderTest2, VertexAttrib3fvImmediateValidArgs) {
1513  cmds::VertexAttrib3fvImmediate& cmd =
1514      *GetImmediateAs<cmds::VertexAttrib3fvImmediate>();
1515  SpecializedSetup<cmds::VertexAttrib3fvImmediate, 0>(true);
1516  GLfloat temp[3] = {0, };
1517  cmd.Init(1, &temp[0]);
1518  EXPECT_CALL(*gl_,
1519              VertexAttrib3fv(
1520                  1, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
1521  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1522  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1523}
1524
1525TEST_F(GLES2DecoderTest2, VertexAttrib4fValidArgs) {
1526  EXPECT_CALL(*gl_, VertexAttrib4f(1, 2, 3, 4, 5));
1527  SpecializedSetup<cmds::VertexAttrib4f, 0>(true);
1528  cmds::VertexAttrib4f cmd;
1529  cmd.Init(1, 2, 3, 4, 5);
1530  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1531  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1532}
1533
1534TEST_F(GLES2DecoderTest2, VertexAttrib4fvValidArgs) {
1535  SpecializedSetup<cmds::VertexAttrib4fv, 0>(true);
1536  cmds::VertexAttrib4fv cmd;
1537  cmd.Init(1, shared_memory_id_, shared_memory_offset_);
1538  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1539  EXPECT_CALL(*gl_,
1540              VertexAttrib4fv(
1541                  1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
1542  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1543  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1544}
1545
1546TEST_F(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_0) {
1547  EXPECT_CALL(*gl_, VertexAttrib4fv(_, _)).Times(0);
1548  SpecializedSetup<cmds::VertexAttrib4fv, 0>(false);
1549  cmds::VertexAttrib4fv cmd;
1550  cmd.Init(1, kInvalidSharedMemoryId, 0);
1551  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1552  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1553}
1554
1555TEST_F(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_1) {
1556  EXPECT_CALL(*gl_, VertexAttrib4fv(_, _)).Times(0);
1557  SpecializedSetup<cmds::VertexAttrib4fv, 0>(false);
1558  cmds::VertexAttrib4fv cmd;
1559  cmd.Init(1, shared_memory_id_, kInvalidSharedMemoryOffset);
1560  GetSharedMemoryAs<GLfloat*>()[0] = 0;
1561  EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1562}
1563
1564TEST_F(GLES2DecoderTest2, VertexAttrib4fvImmediateValidArgs) {
1565  cmds::VertexAttrib4fvImmediate& cmd =
1566      *GetImmediateAs<cmds::VertexAttrib4fvImmediate>();
1567  SpecializedSetup<cmds::VertexAttrib4fvImmediate, 0>(true);
1568  GLfloat temp[4] = {0, };
1569  cmd.Init(1, &temp[0]);
1570  EXPECT_CALL(*gl_,
1571              VertexAttrib4fv(
1572                  1, reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
1573  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1574  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1575}
1576// TODO(gman): VertexAttribPointer
1577
1578TEST_F(GLES2DecoderTest2, ViewportValidArgs) {
1579  EXPECT_CALL(*gl_, Viewport(1, 2, 3, 4));
1580  SpecializedSetup<cmds::Viewport, 0>(true);
1581  cmds::Viewport cmd;
1582  cmd.Init(1, 2, 3, 4);
1583  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1584  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1585}
1586
1587TEST_F(GLES2DecoderTest2, ViewportInvalidArgs2_0) {
1588  EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
1589  SpecializedSetup<cmds::Viewport, 0>(false);
1590  cmds::Viewport cmd;
1591  cmd.Init(1, 2, -1, 4);
1592  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1593  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1594}
1595
1596TEST_F(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
1597  EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
1598  SpecializedSetup<cmds::Viewport, 0>(false);
1599  cmds::Viewport cmd;
1600  cmd.Init(1, 2, 3, -1);
1601  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1602  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1603}
1604// TODO(gman): BlitFramebufferCHROMIUM
1605// TODO(gman): RenderbufferStorageMultisampleCHROMIUM
1606// TODO(gman): RenderbufferStorageMultisampleEXT
1607// TODO(gman): FramebufferTexture2DMultisampleEXT
1608// TODO(gman): TexStorage2DEXT
1609// TODO(gman): GenQueriesEXT
1610// TODO(gman): GenQueriesEXTImmediate
1611// TODO(gman): DeleteQueriesEXT
1612// TODO(gman): DeleteQueriesEXTImmediate
1613// TODO(gman): BeginQueryEXT
1614
1615// TODO(gman): EndQueryEXT
1616
1617// TODO(gman): InsertEventMarkerEXT
1618
1619// TODO(gman): PushGroupMarkerEXT
1620
1621TEST_F(GLES2DecoderTest2, PopGroupMarkerEXTValidArgs) {
1622  SpecializedSetup<cmds::PopGroupMarkerEXT, 0>(true);
1623  cmds::PopGroupMarkerEXT cmd;
1624  cmd.Init();
1625  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1626  EXPECT_EQ(GL_NO_ERROR, GetGLError());
1627}
1628// TODO(gman): GenVertexArraysOES
1629// TODO(gman): GenVertexArraysOESImmediate
1630// TODO(gman): DeleteVertexArraysOES
1631// TODO(gman): DeleteVertexArraysOESImmediate
1632// TODO(gman): IsVertexArrayOES
1633// TODO(gman): BindVertexArrayOES
1634// TODO(gman): SwapBuffers
1635// TODO(gman): GetMaxValueInBufferCHROMIUM
1636// TODO(gman): GenSharedIdsCHROMIUM
1637
1638#endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
1639