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