src/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h

   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_1.cc
  12 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_1_AUTOGEN_H_
  13 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_1_AUTOGEN_H_
  14
  15 // TODO(gman): ActiveTexture
  16
  17 TEST_P(GLES2DecoderTest1, AttachShaderValidArgs) {
  18   EXPECT_CALL(*gl_, AttachShader(kServiceProgramId, kServiceShaderId));
  19   SpecializedSetup<cmds::AttachShader, 0>(true);
  20   cmds::AttachShader cmd;
  21   cmd.Init(client_program_id_, client_shader_id_);
  22   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  23   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  24 }
  25 // TODO(gman): BindAttribLocationBucket
  26
  27 TEST_P(GLES2DecoderTest1, BindBufferValidArgs) {
  28   EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, kServiceBufferId));
  29   SpecializedSetup<cmds::BindBuffer, 0>(true);
  30   cmds::BindBuffer cmd;
  31   cmd.Init(GL_ARRAY_BUFFER, client_buffer_id_);
  32   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  33   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  34 }
  35
  36 TEST_P(GLES2DecoderTest1, BindBufferValidArgsNewId) {
  37   EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, kNewServiceId));
  38   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
  39       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
  40   SpecializedSetup<cmds::BindBuffer, 0>(true);
  41   cmds::BindBuffer cmd;
  42   cmd.Init(GL_ARRAY_BUFFER, kNewClientId);
  43   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  44   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  45   EXPECT_TRUE(GetBuffer(kNewClientId) != NULL);
  46 }
  47
  48 TEST_P(GLES2DecoderTest1, BindBufferInvalidArgs0_0) {
  49   EXPECT_CALL(*gl_, BindBuffer(_, _)).Times(0);
  50   SpecializedSetup<cmds::BindBuffer, 0>(false);
  51   cmds::BindBuffer cmd;
  52   cmd.Init(GL_RENDERBUFFER, client_buffer_id_);
  53   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  54   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
  55 }
  56
  57 TEST_P(GLES2DecoderTest1, BindFramebufferValidArgs) {
  58   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, kServiceFramebufferId));
  59   SpecializedSetup<cmds::BindFramebuffer, 0>(true);
  60   cmds::BindFramebuffer cmd;
  61   cmd.Init(GL_FRAMEBUFFER, client_framebuffer_id_);
  62   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  63   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  64 }
  65
  66 TEST_P(GLES2DecoderTest1, BindFramebufferValidArgsNewId) {
  67   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, kNewServiceId));
  68   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
  69       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
  70   SpecializedSetup<cmds::BindFramebuffer, 0>(true);
  71   cmds::BindFramebuffer cmd;
  72   cmd.Init(GL_FRAMEBUFFER, kNewClientId);
  73   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  74   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  75   EXPECT_TRUE(GetFramebuffer(kNewClientId) != NULL);
  76 }
  77
  78 TEST_P(GLES2DecoderTest1, BindFramebufferInvalidArgs0_0) {
  79   EXPECT_CALL(*gl_, BindFramebufferEXT(_, _)).Times(0);
  80   SpecializedSetup<cmds::BindFramebuffer, 0>(false);
  81   cmds::BindFramebuffer cmd;
  82   cmd.Init(GL_DRAW_FRAMEBUFFER, client_framebuffer_id_);
  83   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  84   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
  85 }
  86
  87 TEST_P(GLES2DecoderTest1, BindFramebufferInvalidArgs0_1) {
  88   EXPECT_CALL(*gl_, BindFramebufferEXT(_, _)).Times(0);
  89   SpecializedSetup<cmds::BindFramebuffer, 0>(false);
  90   cmds::BindFramebuffer cmd;
  91   cmd.Init(GL_READ_FRAMEBUFFER, client_framebuffer_id_);
  92   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  93   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
  94 }
  95
  96 TEST_P(GLES2DecoderTest1, BindRenderbufferValidArgs) {
  97   EXPECT_CALL(*gl_,
  98               BindRenderbufferEXT(GL_RENDERBUFFER, kServiceRenderbufferId));
  99   SpecializedSetup<cmds::BindRenderbuffer, 0>(true);
 100   cmds::BindRenderbuffer cmd;
 101   cmd.Init(GL_RENDERBUFFER, client_renderbuffer_id_);
 102   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 103   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 104 }
 105
 106 TEST_P(GLES2DecoderTest1, BindRenderbufferValidArgsNewId) {
 107   EXPECT_CALL(*gl_, BindRenderbufferEXT(GL_RENDERBUFFER, kNewServiceId));
 108   EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
 109       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
 110   SpecializedSetup<cmds::BindRenderbuffer, 0>(true);
 111   cmds::BindRenderbuffer cmd;
 112   cmd.Init(GL_RENDERBUFFER, kNewClientId);
 113   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 114   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 115   EXPECT_TRUE(GetRenderbuffer(kNewClientId) != NULL);
 116 }
 117
 118 TEST_P(GLES2DecoderTest1, BindRenderbufferInvalidArgs0_0) {
 119   EXPECT_CALL(*gl_, BindRenderbufferEXT(_, _)).Times(0);
 120   SpecializedSetup<cmds::BindRenderbuffer, 0>(false);
 121   cmds::BindRenderbuffer cmd;
 122   cmd.Init(GL_FRAMEBUFFER, client_renderbuffer_id_);
 123   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 124   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 125 }
 126
 127 TEST_P(GLES2DecoderTest1, BindTextureValidArgs) {
 128   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId));
 129   SpecializedSetup<cmds::BindTexture, 0>(true);
 130   cmds::BindTexture cmd;
 131   cmd.Init(GL_TEXTURE_2D, client_texture_id_);
 132   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 133   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 134 }
 135
 136 TEST_P(GLES2DecoderTest1, BindTextureValidArgsNewId) {
 137   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kNewServiceId));
 138   EXPECT_CALL(*gl_, GenTextures(1, _))
 139       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
 140   SpecializedSetup<cmds::BindTexture, 0>(true);
 141   cmds::BindTexture cmd;
 142   cmd.Init(GL_TEXTURE_2D, kNewClientId);
 143   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 144   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 145   EXPECT_TRUE(GetTexture(kNewClientId) != NULL);
 146 }
 147
 148 TEST_P(GLES2DecoderTest1, BindTextureInvalidArgs0_0) {
 149   EXPECT_CALL(*gl_, BindTexture(_, _)).Times(0);
 150   SpecializedSetup<cmds::BindTexture, 0>(false);
 151   cmds::BindTexture cmd;
 152   cmd.Init(GL_TEXTURE_1D, client_texture_id_);
 153   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 154   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 155 }
 156
 157 TEST_P(GLES2DecoderTest1, BindTextureInvalidArgs0_1) {
 158   EXPECT_CALL(*gl_, BindTexture(_, _)).Times(0);
 159   SpecializedSetup<cmds::BindTexture, 0>(false);
 160   cmds::BindTexture cmd;
 161   cmd.Init(GL_TEXTURE_3D, client_texture_id_);
 162   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 163   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 164 }
 165
 166 TEST_P(GLES2DecoderTest1, BlendColorValidArgs) {
 167   EXPECT_CALL(*gl_, BlendColor(1, 2, 3, 4));
 168   SpecializedSetup<cmds::BlendColor, 0>(true);
 169   cmds::BlendColor cmd;
 170   cmd.Init(1, 2, 3, 4);
 171   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 172   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 173 }
 174
 175 TEST_P(GLES2DecoderTest1, BlendEquationValidArgs) {
 176   EXPECT_CALL(*gl_, BlendEquation(GL_FUNC_SUBTRACT));
 177   SpecializedSetup<cmds::BlendEquation, 0>(true);
 178   cmds::BlendEquation cmd;
 179   cmd.Init(GL_FUNC_SUBTRACT);
 180   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 181   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 182 }
 183
 184 TEST_P(GLES2DecoderTest1, BlendEquationInvalidArgs0_0) {
 185   EXPECT_CALL(*gl_, BlendEquation(_)).Times(0);
 186   SpecializedSetup<cmds::BlendEquation, 0>(false);
 187   cmds::BlendEquation cmd;
 188   cmd.Init(GL_MIN);
 189   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 190   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 191 }
 192
 193 TEST_P(GLES2DecoderTest1, BlendEquationInvalidArgs0_1) {
 194   EXPECT_CALL(*gl_, BlendEquation(_)).Times(0);
 195   SpecializedSetup<cmds::BlendEquation, 0>(false);
 196   cmds::BlendEquation cmd;
 197   cmd.Init(GL_MAX);
 198   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 199   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 200 }
 201
 202 TEST_P(GLES2DecoderTest1, BlendEquationSeparateValidArgs) {
 203   EXPECT_CALL(*gl_, BlendEquationSeparate(GL_FUNC_SUBTRACT, GL_FUNC_ADD));
 204   SpecializedSetup<cmds::BlendEquationSeparate, 0>(true);
 205   cmds::BlendEquationSeparate cmd;
 206   cmd.Init(GL_FUNC_SUBTRACT, GL_FUNC_ADD);
 207   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 208   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 209 }
 210
 211 TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_0) {
 212   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
 213   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
 214   cmds::BlendEquationSeparate cmd;
 215   cmd.Init(GL_MIN, GL_FUNC_ADD);
 216   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 217   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 218 }
 219
 220 TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_1) {
 221   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
 222   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
 223   cmds::BlendEquationSeparate cmd;
 224   cmd.Init(GL_MAX, GL_FUNC_ADD);
 225   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 226   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 227 }
 228
 229 TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_0) {
 230   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
 231   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
 232   cmds::BlendEquationSeparate cmd;
 233   cmd.Init(GL_FUNC_SUBTRACT, GL_MIN);
 234   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 235   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 236 }
 237
 238 TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_1) {
 239   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
 240   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
 241   cmds::BlendEquationSeparate cmd;
 242   cmd.Init(GL_FUNC_SUBTRACT, GL_MAX);
 243   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 244   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 245 }
 246
 247 TEST_P(GLES2DecoderTest1, BlendFuncValidArgs) {
 248   EXPECT_CALL(*gl_, BlendFunc(GL_ZERO, GL_ZERO));
 249   SpecializedSetup<cmds::BlendFunc, 0>(true);
 250   cmds::BlendFunc cmd;
 251   cmd.Init(GL_ZERO, GL_ZERO);
 252   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 253   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 254 }
 255
 256 TEST_P(GLES2DecoderTest1, BlendFuncSeparateValidArgs) {
 257   EXPECT_CALL(*gl_, BlendFuncSeparate(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO));
 258   SpecializedSetup<cmds::BlendFuncSeparate, 0>(true);
 259   cmds::BlendFuncSeparate cmd;
 260   cmd.Init(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO);
 261   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 262   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 263 }
 264 // TODO(gman): BufferData
 265
 266 // TODO(gman): BufferSubData
 267
 268 TEST_P(GLES2DecoderTest1, CheckFramebufferStatusValidArgs) {
 269   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER));
 270   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(true);
 271   cmds::CheckFramebufferStatus cmd;
 272   cmd.Init(GL_FRAMEBUFFER, shared_memory_id_, shared_memory_offset_);
 273   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 274   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 275 }
 276
 277 TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_0) {
 278   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(_)).Times(0);
 279   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(false);
 280   cmds::CheckFramebufferStatus cmd;
 281   cmd.Init(GL_DRAW_FRAMEBUFFER, shared_memory_id_, shared_memory_offset_);
 282   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 283   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 284 }
 285
 286 TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_1) {
 287   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(_)).Times(0);
 288   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(false);
 289   cmds::CheckFramebufferStatus cmd;
 290   cmd.Init(GL_READ_FRAMEBUFFER, shared_memory_id_, shared_memory_offset_);
 291   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 292   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 293 }
 294
 295 TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgsBadSharedMemoryId) {
 296   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)).Times(0);
 297   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(false);
 298   cmds::CheckFramebufferStatus cmd;
 299   cmd.Init(GL_FRAMEBUFFER, kInvalidSharedMemoryId, shared_memory_offset_);
 300   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 301   cmd.Init(GL_FRAMEBUFFER, shared_memory_id_, kInvalidSharedMemoryOffset);
 302   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 303 }
 304
 305 TEST_P(GLES2DecoderTest1, ClearValidArgs) {
 306   EXPECT_CALL(*gl_, Clear(1));
 307   SpecializedSetup<cmds::Clear, 0>(true);
 308   cmds::Clear cmd;
 309   cmd.Init(1);
 310   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 311   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 312 }
 313
 314 TEST_P(GLES2DecoderTest1, ClearColorValidArgs) {
 315   EXPECT_CALL(*gl_, ClearColor(1, 2, 3, 4));
 316   SpecializedSetup<cmds::ClearColor, 0>(true);
 317   cmds::ClearColor cmd;
 318   cmd.Init(1, 2, 3, 4);
 319   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 320   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 321 }
 322
 323 TEST_P(GLES2DecoderTest1, ClearDepthfValidArgs) {
 324   EXPECT_CALL(*gl_, ClearDepth(0.5f));
 325   SpecializedSetup<cmds::ClearDepthf, 0>(true);
 326   cmds::ClearDepthf cmd;
 327   cmd.Init(0.5f);
 328   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 329   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 330 }
 331
 332 TEST_P(GLES2DecoderTest1, ClearStencilValidArgs) {
 333   EXPECT_CALL(*gl_, ClearStencil(1));
 334   SpecializedSetup<cmds::ClearStencil, 0>(true);
 335   cmds::ClearStencil cmd;
 336   cmd.Init(1);
 337   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 338   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 339 }
 340
 341 TEST_P(GLES2DecoderTest1, ColorMaskValidArgs) {
 342   SpecializedSetup<cmds::ColorMask, 0>(true);
 343   cmds::ColorMask cmd;
 344   cmd.Init(true, true, true, true);
 345   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 346   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 347 }
 348 // TODO(gman): CompileShader
 349 // TODO(gman): CompressedTexImage2DBucket
 350 // TODO(gman): CompressedTexImage2D
 351
 352 // TODO(gman): CompressedTexSubImage2DBucket
 353 // TODO(gman): CompressedTexSubImage2D
 354
 355 // TODO(gman): CopyTexImage2D
 356
 357 TEST_P(GLES2DecoderTest1, CopyTexSubImage2DValidArgs) {
 358   EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 2, 3, 4, 5, 6, 7, 8));
 359   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(true);
 360   cmds::CopyTexSubImage2D cmd;
 361   cmd.Init(GL_TEXTURE_2D, 2, 3, 4, 5, 6, 7, 8);
 362   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 363   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 364 }
 365
 366 TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs0_0) {
 367   EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
 368   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(false);
 369   cmds::CopyTexSubImage2D cmd;
 370   cmd.Init(GL_PROXY_TEXTURE_CUBE_MAP, 2, 3, 4, 5, 6, 7, 8);
 371   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 372   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 373 }
 374
 375 TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs6_0) {
 376   EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
 377   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(false);
 378   cmds::CopyTexSubImage2D cmd;
 379   cmd.Init(GL_TEXTURE_2D, 2, 3, 4, 5, 6, -1, 8);
 380   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 381   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 382 }
 383
 384 TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs7_0) {
 385   EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
 386   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(false);
 387   cmds::CopyTexSubImage2D cmd;
 388   cmd.Init(GL_TEXTURE_2D, 2, 3, 4, 5, 6, 7, -1);
 389   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 390   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 391 }
 392
 393 TEST_P(GLES2DecoderTest1, CreateProgramValidArgs) {
 394   EXPECT_CALL(*gl_, CreateProgram()).WillOnce(Return(kNewServiceId));
 395   SpecializedSetup<cmds::CreateProgram, 0>(true);
 396   cmds::CreateProgram cmd;
 397   cmd.Init(kNewClientId);
 398   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 399   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 400   EXPECT_TRUE(GetProgram(kNewClientId) != NULL);
 401 }
 402
 403 TEST_P(GLES2DecoderTest1, CreateShaderValidArgs) {
 404   EXPECT_CALL(*gl_, CreateShader(GL_VERTEX_SHADER))
 405       .WillOnce(Return(kNewServiceId));
 406   SpecializedSetup<cmds::CreateShader, 0>(true);
 407   cmds::CreateShader cmd;
 408   cmd.Init(GL_VERTEX_SHADER, kNewClientId);
 409   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 410   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 411   EXPECT_TRUE(GetShader(kNewClientId) != NULL);
 412 }
 413
 414 TEST_P(GLES2DecoderTest1, CreateShaderInvalidArgs0_0) {
 415   EXPECT_CALL(*gl_, CreateShader(_)).Times(0);
 416   SpecializedSetup<cmds::CreateShader, 0>(false);
 417   cmds::CreateShader cmd;
 418   cmd.Init(GL_GEOMETRY_SHADER, kNewClientId);
 419   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 420   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 421 }
 422
 423 TEST_P(GLES2DecoderTest1, CullFaceValidArgs) {
 424   EXPECT_CALL(*gl_, CullFace(GL_FRONT));
 425   SpecializedSetup<cmds::CullFace, 0>(true);
 426   cmds::CullFace cmd;
 427   cmd.Init(GL_FRONT);
 428   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 429   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 430 }
 431
 432 TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateValidArgs) {
 433   EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(kServiceBufferId))).Times(1);
 434   cmds::DeleteBuffersImmediate& cmd =
 435       *GetImmediateAs<cmds::DeleteBuffersImmediate>();
 436   SpecializedSetup<cmds::DeleteBuffersImmediate, 0>(true);
 437   cmd.Init(1, &client_buffer_id_);
 438   EXPECT_EQ(error::kNoError,
 439             ExecuteImmediateCmd(cmd, sizeof(client_buffer_id_)));
 440   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 441   EXPECT_TRUE(GetBuffer(client_buffer_id_) == NULL);
 442 }
 443
 444 TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateInvalidArgs) {
 445   cmds::DeleteBuffersImmediate& cmd =
 446       *GetImmediateAs<cmds::DeleteBuffersImmediate>();
 447   SpecializedSetup<cmds::DeleteBuffersImmediate, 0>(false);
 448   GLuint temp = kInvalidClientId;
 449   cmd.Init(1, &temp);
 450   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 451 }
 452
 453 TEST_P(GLES2DecoderTest1, DeleteFramebuffersImmediateValidArgs) {
 454   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(kServiceFramebufferId)))
 455       .Times(1);
 456   cmds::DeleteFramebuffersImmediate& cmd =
 457       *GetImmediateAs<cmds::DeleteFramebuffersImmediate>();
 458   SpecializedSetup<cmds::DeleteFramebuffersImmediate, 0>(true);
 459   cmd.Init(1, &client_framebuffer_id_);
 460   EXPECT_EQ(error::kNoError,
 461             ExecuteImmediateCmd(cmd, sizeof(client_framebuffer_id_)));
 462   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 463   EXPECT_TRUE(GetFramebuffer(client_framebuffer_id_) == NULL);
 464 }
 465
 466 TEST_P(GLES2DecoderTest1, DeleteFramebuffersImmediateInvalidArgs) {
 467   cmds::DeleteFramebuffersImmediate& cmd =
 468       *GetImmediateAs<cmds::DeleteFramebuffersImmediate>();
 469   SpecializedSetup<cmds::DeleteFramebuffersImmediate, 0>(false);
 470   GLuint temp = kInvalidClientId;
 471   cmd.Init(1, &temp);
 472   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 473 }
 474
 475 TEST_P(GLES2DecoderTest1, DeleteProgramValidArgs) {
 476   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId));
 477   SpecializedSetup<cmds::DeleteProgram, 0>(true);
 478   cmds::DeleteProgram cmd;
 479   cmd.Init(client_program_id_);
 480   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 481   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 482 }
 483
 484 TEST_P(GLES2DecoderTest1, DeleteRenderbuffersImmediateValidArgs) {
 485   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(kServiceRenderbufferId)))
 486       .Times(1);
 487   cmds::DeleteRenderbuffersImmediate& cmd =
 488       *GetImmediateAs<cmds::DeleteRenderbuffersImmediate>();
 489   SpecializedSetup<cmds::DeleteRenderbuffersImmediate, 0>(true);
 490   cmd.Init(1, &client_renderbuffer_id_);
 491   EXPECT_EQ(error::kNoError,
 492             ExecuteImmediateCmd(cmd, sizeof(client_renderbuffer_id_)));
 493   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 494   EXPECT_TRUE(GetRenderbuffer(client_renderbuffer_id_) == NULL);
 495 }
 496
 497 TEST_P(GLES2DecoderTest1, DeleteRenderbuffersImmediateInvalidArgs) {
 498   cmds::DeleteRenderbuffersImmediate& cmd =
 499       *GetImmediateAs<cmds::DeleteRenderbuffersImmediate>();
 500   SpecializedSetup<cmds::DeleteRenderbuffersImmediate, 0>(false);
 501   GLuint temp = kInvalidClientId;
 502   cmd.Init(1, &temp);
 503   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 504 }
 505
 506 TEST_P(GLES2DecoderTest1, DeleteShaderValidArgs) {
 507   EXPECT_CALL(*gl_, DeleteShader(kServiceShaderId));
 508   SpecializedSetup<cmds::DeleteShader, 0>(true);
 509   cmds::DeleteShader cmd;
 510   cmd.Init(client_shader_id_);
 511   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 512   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 513 }
 514
 515 TEST_P(GLES2DecoderTest1, DeleteTexturesImmediateValidArgs) {
 516   EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(kServiceTextureId))).Times(1);
 517   cmds::DeleteTexturesImmediate& cmd =
 518       *GetImmediateAs<cmds::DeleteTexturesImmediate>();
 519   SpecializedSetup<cmds::DeleteTexturesImmediate, 0>(true);
 520   cmd.Init(1, &client_texture_id_);
 521   EXPECT_EQ(error::kNoError,
 522             ExecuteImmediateCmd(cmd, sizeof(client_texture_id_)));
 523   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 524   EXPECT_TRUE(GetTexture(client_texture_id_) == NULL);
 525 }
 526
 527 TEST_P(GLES2DecoderTest1, DeleteTexturesImmediateInvalidArgs) {
 528   cmds::DeleteTexturesImmediate& cmd =
 529       *GetImmediateAs<cmds::DeleteTexturesImmediate>();
 530   SpecializedSetup<cmds::DeleteTexturesImmediate, 0>(false);
 531   GLuint temp = kInvalidClientId;
 532   cmd.Init(1, &temp);
 533   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 534 }
 535
 536 TEST_P(GLES2DecoderTest1, DepthFuncValidArgs) {
 537   EXPECT_CALL(*gl_, DepthFunc(GL_NEVER));
 538   SpecializedSetup<cmds::DepthFunc, 0>(true);
 539   cmds::DepthFunc cmd;
 540   cmd.Init(GL_NEVER);
 541   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 542   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 543 }
 544
 545 TEST_P(GLES2DecoderTest1, DepthMaskValidArgs) {
 546   SpecializedSetup<cmds::DepthMask, 0>(true);
 547   cmds::DepthMask cmd;
 548   cmd.Init(true);
 549   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 550   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 551 }
 552
 553 TEST_P(GLES2DecoderTest1, DepthRangefValidArgs) {
 554   EXPECT_CALL(*gl_, DepthRange(1, 2));
 555   SpecializedSetup<cmds::DepthRangef, 0>(true);
 556   cmds::DepthRangef cmd;
 557   cmd.Init(1, 2);
 558   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 559   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 560 }
 561
 562 TEST_P(GLES2DecoderTest1, DetachShaderValidArgs) {
 563   EXPECT_CALL(*gl_, DetachShader(kServiceProgramId, kServiceShaderId));
 564   SpecializedSetup<cmds::DetachShader, 0>(true);
 565   cmds::DetachShader cmd;
 566   cmd.Init(client_program_id_, client_shader_id_);
 567   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 568   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 569 }
 570
 571 TEST_P(GLES2DecoderTest1, DisableValidArgs) {
 572   SetupExpectationsForEnableDisable(GL_BLEND, false);
 573   SpecializedSetup<cmds::Disable, 0>(true);
 574   cmds::Disable cmd;
 575   cmd.Init(GL_BLEND);
 576   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 577   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 578 }
 579
 580 TEST_P(GLES2DecoderTest1, DisableInvalidArgs0_0) {
 581   EXPECT_CALL(*gl_, Disable(_)).Times(0);
 582   SpecializedSetup<cmds::Disable, 0>(false);
 583   cmds::Disable cmd;
 584   cmd.Init(GL_CLIP_PLANE0);
 585   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 586   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 587 }
 588
 589 TEST_P(GLES2DecoderTest1, DisableInvalidArgs0_1) {
 590   EXPECT_CALL(*gl_, Disable(_)).Times(0);
 591   SpecializedSetup<cmds::Disable, 0>(false);
 592   cmds::Disable cmd;
 593   cmd.Init(GL_POINT_SPRITE);
 594   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 595   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 596 }
 597
 598 TEST_P(GLES2DecoderTest1, DisableVertexAttribArrayValidArgs) {
 599   EXPECT_CALL(*gl_, DisableVertexAttribArray(1));
 600   SpecializedSetup<cmds::DisableVertexAttribArray, 0>(true);
 601   cmds::DisableVertexAttribArray cmd;
 602   cmd.Init(1);
 603   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 604   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 605 }
 606 // TODO(gman): DrawArrays
 607
 608 // TODO(gman): DrawElements
 609
 610 TEST_P(GLES2DecoderTest1, EnableValidArgs) {
 611   SetupExpectationsForEnableDisable(GL_BLEND, true);
 612   SpecializedSetup<cmds::Enable, 0>(true);
 613   cmds::Enable cmd;
 614   cmd.Init(GL_BLEND);
 615   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 616   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 617 }
 618
 619 TEST_P(GLES2DecoderTest1, EnableInvalidArgs0_0) {
 620   EXPECT_CALL(*gl_, Enable(_)).Times(0);
 621   SpecializedSetup<cmds::Enable, 0>(false);
 622   cmds::Enable cmd;
 623   cmd.Init(GL_CLIP_PLANE0);
 624   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 625   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 626 }
 627
 628 TEST_P(GLES2DecoderTest1, EnableInvalidArgs0_1) {
 629   EXPECT_CALL(*gl_, Enable(_)).Times(0);
 630   SpecializedSetup<cmds::Enable, 0>(false);
 631   cmds::Enable cmd;
 632   cmd.Init(GL_POINT_SPRITE);
 633   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 634   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 635 }
 636
 637 TEST_P(GLES2DecoderTest1, EnableVertexAttribArrayValidArgs) {
 638   EXPECT_CALL(*gl_, EnableVertexAttribArray(1));
 639   SpecializedSetup<cmds::EnableVertexAttribArray, 0>(true);
 640   cmds::EnableVertexAttribArray cmd;
 641   cmd.Init(1);
 642   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 643   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 644 }
 645
 646 TEST_P(GLES2DecoderTest1, FinishValidArgs) {
 647   EXPECT_CALL(*gl_, Finish());
 648   SpecializedSetup<cmds::Finish, 0>(true);
 649   cmds::Finish cmd;
 650   cmd.Init();
 651   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 652   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 653 }
 654
 655 TEST_P(GLES2DecoderTest1, FlushValidArgs) {
 656   EXPECT_CALL(*gl_, Flush());
 657   SpecializedSetup<cmds::Flush, 0>(true);
 658   cmds::Flush cmd;
 659   cmd.Init();
 660   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 661   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 662 }
 663
 664 TEST_P(GLES2DecoderTest1, FramebufferRenderbufferValidArgs) {
 665   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
 666                         GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
 667                         kServiceRenderbufferId));
 668   SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(true);
 669   cmds::FramebufferRenderbuffer cmd;
 670   cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
 671            client_renderbuffer_id_);
 672   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 673   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 674 }
 675
 676 TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_0) {
 677   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _)).Times(0);
 678   SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(false);
 679   cmds::FramebufferRenderbuffer cmd;
 680   cmd.Init(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
 681            client_renderbuffer_id_);
 682   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 683   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 684 }
 685
 686 TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_1) {
 687   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _)).Times(0);
 688   SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(false);
 689   cmds::FramebufferRenderbuffer cmd;
 690   cmd.Init(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
 691            client_renderbuffer_id_);
 692   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 693   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 694 }
 695
 696 TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs2_0) {
 697   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _)).Times(0);
 698   SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(false);
 699   cmds::FramebufferRenderbuffer cmd;
 700   cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER,
 701            client_renderbuffer_id_);
 702   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 703   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 704 }
 705
 706 TEST_P(GLES2DecoderTest1, FramebufferTexture2DValidArgs) {
 707   EXPECT_CALL(*gl_,
 708               FramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
 709                                       GL_TEXTURE_2D, kServiceTextureId, 0));
 710   SpecializedSetup<cmds::FramebufferTexture2D, 0>(true);
 711   cmds::FramebufferTexture2D cmd;
 712   cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
 713            client_texture_id_);
 714   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 715   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 716 }
 717
 718 TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_0) {
 719   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
 720   SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
 721   cmds::FramebufferTexture2D cmd;
 722   cmd.Init(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
 723            client_texture_id_);
 724   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 725   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 726 }
 727
 728 TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_1) {
 729   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
 730   SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
 731   cmds::FramebufferTexture2D cmd;
 732   cmd.Init(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
 733            client_texture_id_);
 734   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 735   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 736 }
 737
 738 TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs2_0) {
 739   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
 740   SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
 741   cmds::FramebufferTexture2D cmd;
 742   cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_PROXY_TEXTURE_CUBE_MAP,
 743            client_texture_id_);
 744   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 745   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 746 }
 747
 748 TEST_P(GLES2DecoderTest1, FrontFaceValidArgs) {
 749   EXPECT_CALL(*gl_, FrontFace(GL_CW));
 750   SpecializedSetup<cmds::FrontFace, 0>(true);
 751   cmds::FrontFace cmd;
 752   cmd.Init(GL_CW);
 753   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 754   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 755 }
 756
 757 TEST_P(GLES2DecoderTest1, GenBuffersImmediateValidArgs) {
 758   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
 759       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
 760   cmds::GenBuffersImmediate* cmd = GetImmediateAs<cmds::GenBuffersImmediate>();
 761   GLuint temp = kNewClientId;
 762   SpecializedSetup<cmds::GenBuffersImmediate, 0>(true);
 763   cmd->Init(1, &temp);
 764   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(*cmd, sizeof(temp)));
 765   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 766   EXPECT_TRUE(GetBuffer(kNewClientId) != NULL);
 767 }
 768
 769 TEST_P(GLES2DecoderTest1, GenBuffersImmediateInvalidArgs) {
 770   EXPECT_CALL(*gl_, GenBuffersARB(_, _)).Times(0);
 771   cmds::GenBuffersImmediate* cmd = GetImmediateAs<cmds::GenBuffersImmediate>();
 772   SpecializedSetup<cmds::GenBuffersImmediate, 0>(false);
 773   cmd->Init(1, &client_buffer_id_);
 774   EXPECT_EQ(error::kInvalidArguments,
 775             ExecuteImmediateCmd(*cmd, sizeof(&client_buffer_id_)));
 776 }
 777
 778 TEST_P(GLES2DecoderTest1, GenerateMipmapValidArgs) {
 779   EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D));
 780   SpecializedSetup<cmds::GenerateMipmap, 0>(true);
 781   cmds::GenerateMipmap cmd;
 782   cmd.Init(GL_TEXTURE_2D);
 783   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 784   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 785 }
 786
 787 TEST_P(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_0) {
 788   EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
 789   SpecializedSetup<cmds::GenerateMipmap, 0>(false);
 790   cmds::GenerateMipmap cmd;
 791   cmd.Init(GL_TEXTURE_1D);
 792   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 793   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 794 }
 795
 796 TEST_P(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_1) {
 797   EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
 798   SpecializedSetup<cmds::GenerateMipmap, 0>(false);
 799   cmds::GenerateMipmap cmd;
 800   cmd.Init(GL_TEXTURE_3D);
 801   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 802   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 803 }
 804
 805 TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateValidArgs) {
 806   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
 807       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
 808   cmds::GenFramebuffersImmediate* cmd =
 809       GetImmediateAs<cmds::GenFramebuffersImmediate>();
 810   GLuint temp = kNewClientId;
 811   SpecializedSetup<cmds::GenFramebuffersImmediate, 0>(true);
 812   cmd->Init(1, &temp);
 813   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(*cmd, sizeof(temp)));
 814   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 815   EXPECT_TRUE(GetFramebuffer(kNewClientId) != NULL);
 816 }
 817
 818 TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateInvalidArgs) {
 819   EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _)).Times(0);
 820   cmds::GenFramebuffersImmediate* cmd =
 821       GetImmediateAs<cmds::GenFramebuffersImmediate>();
 822   SpecializedSetup<cmds::GenFramebuffersImmediate, 0>(false);
 823   cmd->Init(1, &client_framebuffer_id_);
 824   EXPECT_EQ(error::kInvalidArguments,
 825             ExecuteImmediateCmd(*cmd, sizeof(&client_framebuffer_id_)));
 826 }
 827
 828 TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateValidArgs) {
 829   EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
 830       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
 831   cmds::GenRenderbuffersImmediate* cmd =
 832       GetImmediateAs<cmds::GenRenderbuffersImmediate>();
 833   GLuint temp = kNewClientId;
 834   SpecializedSetup<cmds::GenRenderbuffersImmediate, 0>(true);
 835   cmd->Init(1, &temp);
 836   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(*cmd, sizeof(temp)));
 837   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 838   EXPECT_TRUE(GetRenderbuffer(kNewClientId) != NULL);
 839 }
 840
 841 TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateInvalidArgs) {
 842   EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _)).Times(0);
 843   cmds::GenRenderbuffersImmediate* cmd =
 844       GetImmediateAs<cmds::GenRenderbuffersImmediate>();
 845   SpecializedSetup<cmds::GenRenderbuffersImmediate, 0>(false);
 846   cmd->Init(1, &client_renderbuffer_id_);
 847   EXPECT_EQ(error::kInvalidArguments,
 848             ExecuteImmediateCmd(*cmd, sizeof(&client_renderbuffer_id_)));
 849 }
 850
 851 TEST_P(GLES2DecoderTest1, GenTexturesImmediateValidArgs) {
 852   EXPECT_CALL(*gl_, GenTextures(1, _))
 853       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
 854   cmds::GenTexturesImmediate* cmd =
 855       GetImmediateAs<cmds::GenTexturesImmediate>();
 856   GLuint temp = kNewClientId;
 857   SpecializedSetup<cmds::GenTexturesImmediate, 0>(true);
 858   cmd->Init(1, &temp);
 859   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(*cmd, sizeof(temp)));
 860   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 861   EXPECT_TRUE(GetTexture(kNewClientId) != NULL);
 862 }
 863
 864 TEST_P(GLES2DecoderTest1, GenTexturesImmediateInvalidArgs) {
 865   EXPECT_CALL(*gl_, GenTextures(_, _)).Times(0);
 866   cmds::GenTexturesImmediate* cmd =
 867       GetImmediateAs<cmds::GenTexturesImmediate>();
 868   SpecializedSetup<cmds::GenTexturesImmediate, 0>(false);
 869   cmd->Init(1, &client_texture_id_);
 870   EXPECT_EQ(error::kInvalidArguments,
 871             ExecuteImmediateCmd(*cmd, sizeof(&client_texture_id_)));
 872 }
 873 // TODO(gman): GetActiveAttrib
 874
 875 // TODO(gman): GetActiveUniform
 876
 877 // TODO(gman): GetAttachedShaders
 878
 879 // TODO(gman): GetAttribLocation
 880
 881 TEST_P(GLES2DecoderTest1, GetBooleanvValidArgs) {
 882   EXPECT_CALL(*gl_, GetError())
 883       .WillOnce(Return(GL_NO_ERROR))
 884       .WillOnce(Return(GL_NO_ERROR))
 885       .RetiresOnSaturation();
 886   SpecializedSetup<cmds::GetBooleanv, 0>(true);
 887   typedef cmds::GetBooleanv::Result Result;
 888   Result* result = static_cast<Result*>(shared_memory_address_);
 889   EXPECT_CALL(*gl_, GetBooleanv(GL_ACTIVE_TEXTURE, result->GetData()));
 890   result->size = 0;
 891   cmds::GetBooleanv cmd;
 892   cmd.Init(GL_ACTIVE_TEXTURE, shared_memory_id_, shared_memory_offset_);
 893   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 894   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ACTIVE_TEXTURE),
 895             result->GetNumResults());
 896   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 897 }
 898
 899 TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs0_0) {
 900   EXPECT_CALL(*gl_, GetBooleanv(_, _)).Times(0);
 901   SpecializedSetup<cmds::GetBooleanv, 0>(false);
 902   cmds::GetBooleanv::Result* result =
 903       static_cast<cmds::GetBooleanv::Result*>(shared_memory_address_);
 904   result->size = 0;
 905   cmds::GetBooleanv cmd;
 906   cmd.Init(GL_FOG_HINT, shared_memory_id_, shared_memory_offset_);
 907   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 908   EXPECT_EQ(0u, result->size);
 909   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 910 }
 911
 912 TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs1_0) {
 913   EXPECT_CALL(*gl_, GetBooleanv(_, _)).Times(0);
 914   SpecializedSetup<cmds::GetBooleanv, 0>(false);
 915   cmds::GetBooleanv::Result* result =
 916       static_cast<cmds::GetBooleanv::Result*>(shared_memory_address_);
 917   result->size = 0;
 918   cmds::GetBooleanv cmd;
 919   cmd.Init(GL_ACTIVE_TEXTURE, kInvalidSharedMemoryId, 0);
 920   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 921   EXPECT_EQ(0u, result->size);
 922 }
 923
 924 TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs1_1) {
 925   EXPECT_CALL(*gl_, GetBooleanv(_, _)).Times(0);
 926   SpecializedSetup<cmds::GetBooleanv, 0>(false);
 927   cmds::GetBooleanv::Result* result =
 928       static_cast<cmds::GetBooleanv::Result*>(shared_memory_address_);
 929   result->size = 0;
 930   cmds::GetBooleanv cmd;
 931   cmd.Init(GL_ACTIVE_TEXTURE, shared_memory_id_, kInvalidSharedMemoryOffset);
 932   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 933   EXPECT_EQ(0u, result->size);
 934 }
 935
 936 TEST_P(GLES2DecoderTest1, GetBufferParameterivValidArgs) {
 937   SpecializedSetup<cmds::GetBufferParameteriv, 0>(true);
 938   typedef cmds::GetBufferParameteriv::Result Result;
 939   Result* result = static_cast<Result*>(shared_memory_address_);
 940   result->size = 0;
 941   cmds::GetBufferParameteriv cmd;
 942   cmd.Init(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, shared_memory_id_,
 943            shared_memory_offset_);
 944   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 945   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_BUFFER_SIZE),
 946             result->GetNumResults());
 947   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 948 }
 949
 950 TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs0_0) {
 951   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
 952   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
 953   cmds::GetBufferParameteriv::Result* result =
 954       static_cast<cmds::GetBufferParameteriv::Result*>(shared_memory_address_);
 955   result->size = 0;
 956   cmds::GetBufferParameteriv cmd;
 957   cmd.Init(GL_RENDERBUFFER, GL_BUFFER_SIZE, shared_memory_id_,
 958            shared_memory_offset_);
 959   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 960   EXPECT_EQ(0u, result->size);
 961   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 962 }
 963
 964 TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs1_0) {
 965   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
 966   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
 967   cmds::GetBufferParameteriv::Result* result =
 968       static_cast<cmds::GetBufferParameteriv::Result*>(shared_memory_address_);
 969   result->size = 0;
 970   cmds::GetBufferParameteriv cmd;
 971   cmd.Init(GL_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, shared_memory_id_,
 972            shared_memory_offset_);
 973   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 974   EXPECT_EQ(0u, result->size);
 975   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 976 }
 977
 978 TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_0) {
 979   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
 980   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
 981   cmds::GetBufferParameteriv::Result* result =
 982       static_cast<cmds::GetBufferParameteriv::Result*>(shared_memory_address_);
 983   result->size = 0;
 984   cmds::GetBufferParameteriv cmd;
 985   cmd.Init(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, kInvalidSharedMemoryId, 0);
 986   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 987   EXPECT_EQ(0u, result->size);
 988 }
 989
 990 TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_1) {
 991   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
 992   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
 993   cmds::GetBufferParameteriv::Result* result =
 994       static_cast<cmds::GetBufferParameteriv::Result*>(shared_memory_address_);
 995   result->size = 0;
 996   cmds::GetBufferParameteriv cmd;
 997   cmd.Init(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, shared_memory_id_,
 998            kInvalidSharedMemoryOffset);
 999   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1000   EXPECT_EQ(0u, result->size);
1001 }
1002
1003 TEST_P(GLES2DecoderTest1, GetErrorValidArgs) {
1004   EXPECT_CALL(*gl_, GetError());
1005   SpecializedSetup<cmds::GetError, 0>(true);
1006   cmds::GetError cmd;
1007   cmd.Init(shared_memory_id_, shared_memory_offset_);
1008   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1009   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1010 }
1011
1012 TEST_P(GLES2DecoderTest1, GetErrorInvalidArgsBadSharedMemoryId) {
1013   EXPECT_CALL(*gl_, GetError()).Times(0);
1014   SpecializedSetup<cmds::GetError, 0>(false);
1015   cmds::GetError cmd;
1016   cmd.Init(kInvalidSharedMemoryId, shared_memory_offset_);
1017   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1018   cmd.Init(shared_memory_id_, kInvalidSharedMemoryOffset);
1019   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1020 }
1021
1022 TEST_P(GLES2DecoderTest1, GetFloatvValidArgs) {
1023   EXPECT_CALL(*gl_, GetError())
1024       .WillOnce(Return(GL_NO_ERROR))
1025       .WillOnce(Return(GL_NO_ERROR))
1026       .RetiresOnSaturation();
1027   SpecializedSetup<cmds::GetFloatv, 0>(true);
1028   typedef cmds::GetFloatv::Result Result;
1029   Result* result = static_cast<Result*>(shared_memory_address_);
1030   EXPECT_CALL(*gl_, GetFloatv(GL_ACTIVE_TEXTURE, result->GetData()));
1031   result->size = 0;
1032   cmds::GetFloatv cmd;
1033   cmd.Init(GL_ACTIVE_TEXTURE, shared_memory_id_, shared_memory_offset_);
1034   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1035   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ACTIVE_TEXTURE),
1036             result->GetNumResults());
1037   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1038 }
1039
1040 TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs0_0) {
1041   EXPECT_CALL(*gl_, GetFloatv(_, _)).Times(0);
1042   SpecializedSetup<cmds::GetFloatv, 0>(false);
1043   cmds::GetFloatv::Result* result =
1044       static_cast<cmds::GetFloatv::Result*>(shared_memory_address_);
1045   result->size = 0;
1046   cmds::GetFloatv cmd;
1047   cmd.Init(GL_FOG_HINT, shared_memory_id_, shared_memory_offset_);
1048   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1049   EXPECT_EQ(0u, result->size);
1050   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1051 }
1052
1053 TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs1_0) {
1054   EXPECT_CALL(*gl_, GetFloatv(_, _)).Times(0);
1055   SpecializedSetup<cmds::GetFloatv, 0>(false);
1056   cmds::GetFloatv::Result* result =
1057       static_cast<cmds::GetFloatv::Result*>(shared_memory_address_);
1058   result->size = 0;
1059   cmds::GetFloatv cmd;
1060   cmd.Init(GL_ACTIVE_TEXTURE, kInvalidSharedMemoryId, 0);
1061   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1062   EXPECT_EQ(0u, result->size);
1063 }
1064
1065 TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs1_1) {
1066   EXPECT_CALL(*gl_, GetFloatv(_, _)).Times(0);
1067   SpecializedSetup<cmds::GetFloatv, 0>(false);
1068   cmds::GetFloatv::Result* result =
1069       static_cast<cmds::GetFloatv::Result*>(shared_memory_address_);
1070   result->size = 0;
1071   cmds::GetFloatv cmd;
1072   cmd.Init(GL_ACTIVE_TEXTURE, shared_memory_id_, kInvalidSharedMemoryOffset);
1073   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1074   EXPECT_EQ(0u, result->size);
1075 }
1076
1077 TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivValidArgs) {
1078   EXPECT_CALL(*gl_, GetError())
1079       .WillOnce(Return(GL_NO_ERROR))
1080       .WillOnce(Return(GL_NO_ERROR))
1081       .RetiresOnSaturation();
1082   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(true);
1083   typedef cmds::GetFramebufferAttachmentParameteriv::Result Result;
1084   Result* result = static_cast<Result*>(shared_memory_address_);
1085   EXPECT_CALL(*gl_,
1086               GetFramebufferAttachmentParameterivEXT(
1087                   GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
1088                   GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, result->GetData()));
1089   result->size = 0;
1090   cmds::GetFramebufferAttachmentParameteriv cmd;
1091   cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
1092            GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, shared_memory_id_,
1093            shared_memory_offset_);
1094   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1095   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
1096                 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE),
1097             result->GetNumResults());
1098   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1099 }
1100
1101 TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_0) {
1102   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
1103       .Times(0);
1104   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
1105   cmds::GetFramebufferAttachmentParameteriv::Result* result =
1106       static_cast<cmds::GetFramebufferAttachmentParameteriv::Result*>(
1107           shared_memory_address_);
1108   result->size = 0;
1109   cmds::GetFramebufferAttachmentParameteriv cmd;
1110   cmd.Init(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
1111            GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, shared_memory_id_,
1112            shared_memory_offset_);
1113   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1114   EXPECT_EQ(0u, result->size);
1115   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1116 }
1117
1118 TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_1) {
1119   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
1120       .Times(0);
1121   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
1122   cmds::GetFramebufferAttachmentParameteriv::Result* result =
1123       static_cast<cmds::GetFramebufferAttachmentParameteriv::Result*>(
1124           shared_memory_address_);
1125   result->size = 0;
1126   cmds::GetFramebufferAttachmentParameteriv cmd;
1127   cmd.Init(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
1128            GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, shared_memory_id_,
1129            shared_memory_offset_);
1130   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1131   EXPECT_EQ(0u, result->size);
1132   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1133 }
1134
1135 TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_0) {
1136   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
1137       .Times(0);
1138   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
1139   cmds::GetFramebufferAttachmentParameteriv::Result* result =
1140       static_cast<cmds::GetFramebufferAttachmentParameteriv::Result*>(
1141           shared_memory_address_);
1142   result->size = 0;
1143   cmds::GetFramebufferAttachmentParameteriv cmd;
1144   cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
1145            GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, kInvalidSharedMemoryId, 0);
1146   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1147   EXPECT_EQ(0u, result->size);
1148 }
1149
1150 TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_1) {
1151   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
1152       .Times(0);
1153   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
1154   cmds::GetFramebufferAttachmentParameteriv::Result* result =
1155       static_cast<cmds::GetFramebufferAttachmentParameteriv::Result*>(
1156           shared_memory_address_);
1157   result->size = 0;
1158   cmds::GetFramebufferAttachmentParameteriv cmd;
1159   cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
1160            GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, shared_memory_id_,
1161            kInvalidSharedMemoryOffset);
1162   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1163   EXPECT_EQ(0u, result->size);
1164 }
1165
1166 TEST_P(GLES2DecoderTest1, GetIntegervValidArgs) {
1167   EXPECT_CALL(*gl_, GetError())
1168       .WillOnce(Return(GL_NO_ERROR))
1169       .WillOnce(Return(GL_NO_ERROR))
1170       .RetiresOnSaturation();
1171   SpecializedSetup<cmds::GetIntegerv, 0>(true);
1172   typedef cmds::GetIntegerv::Result Result;
1173   Result* result = static_cast<Result*>(shared_memory_address_);
1174   EXPECT_CALL(*gl_, GetIntegerv(GL_ACTIVE_TEXTURE, result->GetData()));
1175   result->size = 0;
1176   cmds::GetIntegerv cmd;
1177   cmd.Init(GL_ACTIVE_TEXTURE, shared_memory_id_, shared_memory_offset_);
1178   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1179   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ACTIVE_TEXTURE),
1180             result->GetNumResults());
1181   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1182 }
1183
1184 TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs0_0) {
1185   EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0);
1186   SpecializedSetup<cmds::GetIntegerv, 0>(false);
1187   cmds::GetIntegerv::Result* result =
1188       static_cast<cmds::GetIntegerv::Result*>(shared_memory_address_);
1189   result->size = 0;
1190   cmds::GetIntegerv cmd;
1191   cmd.Init(GL_FOG_HINT, shared_memory_id_, shared_memory_offset_);
1192   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1193   EXPECT_EQ(0u, result->size);
1194   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1195 }
1196
1197 TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs1_0) {
1198   EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0);
1199   SpecializedSetup<cmds::GetIntegerv, 0>(false);
1200   cmds::GetIntegerv::Result* result =
1201       static_cast<cmds::GetIntegerv::Result*>(shared_memory_address_);
1202   result->size = 0;
1203   cmds::GetIntegerv cmd;
1204   cmd.Init(GL_ACTIVE_TEXTURE, kInvalidSharedMemoryId, 0);
1205   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1206   EXPECT_EQ(0u, result->size);
1207 }
1208
1209 TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs1_1) {
1210   EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0);
1211   SpecializedSetup<cmds::GetIntegerv, 0>(false);
1212   cmds::GetIntegerv::Result* result =
1213       static_cast<cmds::GetIntegerv::Result*>(shared_memory_address_);
1214   result->size = 0;
1215   cmds::GetIntegerv cmd;
1216   cmd.Init(GL_ACTIVE_TEXTURE, shared_memory_id_, kInvalidSharedMemoryOffset);
1217   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1218   EXPECT_EQ(0u, result->size);
1219 }
1220
1221 TEST_P(GLES2DecoderTest1, GetProgramivValidArgs) {
1222   SpecializedSetup<cmds::GetProgramiv, 0>(true);
1223   typedef cmds::GetProgramiv::Result Result;
1224   Result* result = static_cast<Result*>(shared_memory_address_);
1225   result->size = 0;
1226   cmds::GetProgramiv cmd;
1227   cmd.Init(client_program_id_, GL_DELETE_STATUS, shared_memory_id_,
1228            shared_memory_offset_);
1229   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1230   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DELETE_STATUS),
1231             result->GetNumResults());
1232   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1233 }
1234
1235 TEST_P(GLES2DecoderTest1, GetProgramivInvalidArgs2_0) {
1236   EXPECT_CALL(*gl_, GetProgramiv(_, _, _)).Times(0);
1237   SpecializedSetup<cmds::GetProgramiv, 0>(false);
1238   cmds::GetProgramiv::Result* result =
1239       static_cast<cmds::GetProgramiv::Result*>(shared_memory_address_);
1240   result->size = 0;
1241   cmds::GetProgramiv cmd;
1242   cmd.Init(client_program_id_, GL_DELETE_STATUS, kInvalidSharedMemoryId, 0);
1243   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1244   EXPECT_EQ(0u, result->size);
1245 }
1246
1247 TEST_P(GLES2DecoderTest1, GetProgramivInvalidArgs2_1) {
1248   EXPECT_CALL(*gl_, GetProgramiv(_, _, _)).Times(0);
1249   SpecializedSetup<cmds::GetProgramiv, 0>(false);
1250   cmds::GetProgramiv::Result* result =
1251       static_cast<cmds::GetProgramiv::Result*>(shared_memory_address_);
1252   result->size = 0;
1253   cmds::GetProgramiv cmd;
1254   cmd.Init(client_program_id_, GL_DELETE_STATUS, shared_memory_id_,
1255            kInvalidSharedMemoryOffset);
1256   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1257   EXPECT_EQ(0u, result->size);
1258 }
1259
1260 TEST_P(GLES2DecoderTest1, GetProgramInfoLogValidArgs) {
1261   const char* kInfo = "hello";
1262   const uint32_t kBucketId = 123;
1263   SpecializedSetup<cmds::GetProgramInfoLog, 0>(true);
1264
1265   cmds::GetProgramInfoLog cmd;
1266   cmd.Init(client_program_id_, kBucketId);
1267   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1268   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
1269   ASSERT_TRUE(bucket != NULL);
1270   EXPECT_EQ(strlen(kInfo) + 1, bucket->size());
1271   EXPECT_EQ(0,
1272             memcmp(bucket->GetData(0, bucket->size()), kInfo, bucket->size()));
1273   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1274 }
1275
1276 TEST_P(GLES2DecoderTest1, GetProgramInfoLogInvalidArgs) {
1277   const uint32_t kBucketId = 123;
1278   cmds::GetProgramInfoLog cmd;
1279   cmd.Init(kInvalidClientId, kBucketId);
1280   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1281   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1282 }
1283
1284 TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivValidArgs) {
1285   EXPECT_CALL(*gl_, GetError())
1286       .WillOnce(Return(GL_NO_ERROR))
1287       .WillOnce(Return(GL_NO_ERROR))
1288       .RetiresOnSaturation();
1289   SpecializedSetup<cmds::GetRenderbufferParameteriv, 0>(true);
1290   typedef cmds::GetRenderbufferParameteriv::Result Result;
1291   Result* result = static_cast<Result*>(shared_memory_address_);
1292   EXPECT_CALL(
1293       *gl_, GetRenderbufferParameterivEXT(
1294                 GL_RENDERBUFFER, GL_RENDERBUFFER_RED_SIZE, result->GetData()));
1295   result->size = 0;
1296   cmds::GetRenderbufferParameteriv cmd;
1297   cmd.Init(GL_RENDERBUFFER, GL_RENDERBUFFER_RED_SIZE, shared_memory_id_,
1298            shared_memory_offset_);
1299   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1300   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
1301                 GL_RENDERBUFFER_RED_SIZE),
1302             result->GetNumResults());
1303   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1304 }
1305
1306 TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs0_0) {
1307   EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _)).Times(0);
1308   SpecializedSetup<cmds::GetRenderbufferParameteriv, 0>(false);
1309   cmds::GetRenderbufferParameteriv::Result* result =
1310       static_cast<cmds::GetRenderbufferParameteriv::Result*>(
1311           shared_memory_address_);
1312   result->size = 0;
1313   cmds::GetRenderbufferParameteriv cmd;
1314   cmd.Init(GL_FRAMEBUFFER, GL_RENDERBUFFER_RED_SIZE, shared_memory_id_,
1315            shared_memory_offset_);
1316   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1317   EXPECT_EQ(0u, result->size);
1318   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1319 }
1320
1321 TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_0) {
1322   EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _)).Times(0);
1323   SpecializedSetup<cmds::GetRenderbufferParameteriv, 0>(false);
1324   cmds::GetRenderbufferParameteriv::Result* result =
1325       static_cast<cmds::GetRenderbufferParameteriv::Result*>(
1326           shared_memory_address_);
1327   result->size = 0;
1328   cmds::GetRenderbufferParameteriv cmd;
1329   cmd.Init(GL_RENDERBUFFER, GL_RENDERBUFFER_RED_SIZE, kInvalidSharedMemoryId,
1330            0);
1331   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1332   EXPECT_EQ(0u, result->size);
1333 }
1334
1335 TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_1) {
1336   EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _)).Times(0);
1337   SpecializedSetup<cmds::GetRenderbufferParameteriv, 0>(false);
1338   cmds::GetRenderbufferParameteriv::Result* result =
1339       static_cast<cmds::GetRenderbufferParameteriv::Result*>(
1340           shared_memory_address_);
1341   result->size = 0;
1342   cmds::GetRenderbufferParameteriv cmd;
1343   cmd.Init(GL_RENDERBUFFER, GL_RENDERBUFFER_RED_SIZE, shared_memory_id_,
1344            kInvalidSharedMemoryOffset);
1345   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1346   EXPECT_EQ(0u, result->size);
1347 }
1348
1349 TEST_P(GLES2DecoderTest1, GetShaderivValidArgs) {
1350   EXPECT_CALL(*gl_, GetError())
1351       .WillOnce(Return(GL_NO_ERROR))
1352       .WillOnce(Return(GL_NO_ERROR))
1353       .RetiresOnSaturation();
1354   SpecializedSetup<cmds::GetShaderiv, 0>(true);
1355   typedef cmds::GetShaderiv::Result Result;
1356   Result* result = static_cast<Result*>(shared_memory_address_);
1357   EXPECT_CALL(*gl_,
1358               GetShaderiv(kServiceShaderId, GL_SHADER_TYPE, result->GetData()));
1359   result->size = 0;
1360   cmds::GetShaderiv cmd;
1361   cmd.Init(client_shader_id_, GL_SHADER_TYPE, shared_memory_id_,
1362            shared_memory_offset_);
1363   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1364   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_SHADER_TYPE),
1365             result->GetNumResults());
1366   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1367 }
1368
1369 TEST_P(GLES2DecoderTest1, GetShaderivInvalidArgs2_0) {
1370   EXPECT_CALL(*gl_, GetShaderiv(_, _, _)).Times(0);
1371   SpecializedSetup<cmds::GetShaderiv, 0>(false);
1372   cmds::GetShaderiv::Result* result =
1373       static_cast<cmds::GetShaderiv::Result*>(shared_memory_address_);
1374   result->size = 0;
1375   cmds::GetShaderiv cmd;
1376   cmd.Init(client_shader_id_, GL_SHADER_TYPE, kInvalidSharedMemoryId, 0);
1377   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1378   EXPECT_EQ(0u, result->size);
1379 }
1380
1381 TEST_P(GLES2DecoderTest1, GetShaderivInvalidArgs2_1) {
1382   EXPECT_CALL(*gl_, GetShaderiv(_, _, _)).Times(0);
1383   SpecializedSetup<cmds::GetShaderiv, 0>(false);
1384   cmds::GetShaderiv::Result* result =
1385       static_cast<cmds::GetShaderiv::Result*>(shared_memory_address_);
1386   result->size = 0;
1387   cmds::GetShaderiv cmd;
1388   cmd.Init(client_shader_id_, GL_SHADER_TYPE, shared_memory_id_,
1389            kInvalidSharedMemoryOffset);
1390   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1391   EXPECT_EQ(0u, result->size);
1392 }
1393 // TODO(gman): GetShaderInfoLog
1394 // TODO(gman): GetShaderPrecisionFormat
1395
1396 // TODO(gman): GetShaderSource
1397 // TODO(gman): GetString
1398
1399 TEST_P(GLES2DecoderTest1, GetTexParameterfvValidArgs) {
1400   EXPECT_CALL(*gl_, GetError())
1401       .WillOnce(Return(GL_NO_ERROR))
1402       .WillOnce(Return(GL_NO_ERROR))
1403       .RetiresOnSaturation();
1404   SpecializedSetup<cmds::GetTexParameterfv, 0>(true);
1405   typedef cmds::GetTexParameterfv::Result Result;
1406   Result* result = static_cast<Result*>(shared_memory_address_);
1407   EXPECT_CALL(*gl_, GetTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
1408                                       result->GetData()));
1409   result->size = 0;
1410   cmds::GetTexParameterfv cmd;
1411   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
1412            shared_memory_offset_);
1413   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1414   EXPECT_EQ(
1415       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_TEXTURE_MAG_FILTER),
1416       result->GetNumResults());
1417   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1418 }
1419
1420 TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs0_0) {
1421   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
1422   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
1423   cmds::GetTexParameterfv::Result* result =
1424       static_cast<cmds::GetTexParameterfv::Result*>(shared_memory_address_);
1425   result->size = 0;
1426   cmds::GetTexParameterfv cmd;
1427   cmd.Init(GL_PROXY_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
1428            shared_memory_offset_);
1429   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1430   EXPECT_EQ(0u, result->size);
1431   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1432 }
1433
1434 TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs1_0) {
1435   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
1436   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
1437   cmds::GetTexParameterfv::Result* result =
1438       static_cast<cmds::GetTexParameterfv::Result*>(shared_memory_address_);
1439   result->size = 0;
1440   cmds::GetTexParameterfv cmd;
1441   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, shared_memory_id_,
1442            shared_memory_offset_);
1443   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1444   EXPECT_EQ(0u, result->size);
1445   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1446 }
1447
1448 TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_0) {
1449   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
1450   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
1451   cmds::GetTexParameterfv::Result* result =
1452       static_cast<cmds::GetTexParameterfv::Result*>(shared_memory_address_);
1453   result->size = 0;
1454   cmds::GetTexParameterfv cmd;
1455   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
1456   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1457   EXPECT_EQ(0u, result->size);
1458 }
1459
1460 TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_1) {
1461   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
1462   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
1463   cmds::GetTexParameterfv::Result* result =
1464       static_cast<cmds::GetTexParameterfv::Result*>(shared_memory_address_);
1465   result->size = 0;
1466   cmds::GetTexParameterfv cmd;
1467   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
1468            kInvalidSharedMemoryOffset);
1469   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1470   EXPECT_EQ(0u, result->size);
1471 }
1472
1473 TEST_P(GLES2DecoderTest1, GetTexParameterivValidArgs) {
1474   EXPECT_CALL(*gl_, GetError())
1475       .WillOnce(Return(GL_NO_ERROR))
1476       .WillOnce(Return(GL_NO_ERROR))
1477       .RetiresOnSaturation();
1478   SpecializedSetup<cmds::GetTexParameteriv, 0>(true);
1479   typedef cmds::GetTexParameteriv::Result Result;
1480   Result* result = static_cast<Result*>(shared_memory_address_);
1481   EXPECT_CALL(*gl_, GetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
1482                                       result->GetData()));
1483   result->size = 0;
1484   cmds::GetTexParameteriv cmd;
1485   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
1486            shared_memory_offset_);
1487   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1488   EXPECT_EQ(
1489       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_TEXTURE_MAG_FILTER),
1490       result->GetNumResults());
1491   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1492 }
1493
1494 TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs0_0) {
1495   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
1496   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
1497   cmds::GetTexParameteriv::Result* result =
1498       static_cast<cmds::GetTexParameteriv::Result*>(shared_memory_address_);
1499   result->size = 0;
1500   cmds::GetTexParameteriv cmd;
1501   cmd.Init(GL_PROXY_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
1502            shared_memory_offset_);
1503   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1504   EXPECT_EQ(0u, result->size);
1505   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1506 }
1507
1508 TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs1_0) {
1509   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
1510   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
1511   cmds::GetTexParameteriv::Result* result =
1512       static_cast<cmds::GetTexParameteriv::Result*>(shared_memory_address_);
1513   result->size = 0;
1514   cmds::GetTexParameteriv cmd;
1515   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, shared_memory_id_,
1516            shared_memory_offset_);
1517   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1518   EXPECT_EQ(0u, result->size);
1519   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1520 }
1521
1522 TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_0) {
1523   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
1524   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
1525   cmds::GetTexParameteriv::Result* result =
1526       static_cast<cmds::GetTexParameteriv::Result*>(shared_memory_address_);
1527   result->size = 0;
1528   cmds::GetTexParameteriv cmd;
1529   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
1530   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1531   EXPECT_EQ(0u, result->size);
1532 }
1533
1534 TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_1) {
1535   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
1536   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
1537   cmds::GetTexParameteriv::Result* result =
1538       static_cast<cmds::GetTexParameteriv::Result*>(shared_memory_address_);
1539   result->size = 0;
1540   cmds::GetTexParameteriv cmd;
1541   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
1542            kInvalidSharedMemoryOffset);
1543   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1544   EXPECT_EQ(0u, result->size);
1545 }
1546 // TODO(gman): GetUniformfv
1547
1548 // TODO(gman): GetUniformiv
1549
1550 // TODO(gman): GetUniformLocation
1551
1552 TEST_P(GLES2DecoderTest1, GetVertexAttribfvValidArgs) {
1553   SpecializedSetup<cmds::GetVertexAttribfv, 0>(true);
1554   typedef cmds::GetVertexAttribfv::Result Result;
1555   Result* result = static_cast<Result*>(shared_memory_address_);
1556   result->size = 0;
1557   cmds::GetVertexAttribfv cmd;
1558   cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
1559            shared_memory_offset_);
1560   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1561   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
1562                 GL_VERTEX_ATTRIB_ARRAY_NORMALIZED),
1563             result->GetNumResults());
1564   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1565 }
1566
1567 TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_0) {
1568   EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
1569   SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
1570   cmds::GetVertexAttribfv::Result* result =
1571       static_cast<cmds::GetVertexAttribfv::Result*>(shared_memory_address_);
1572   result->size = 0;
1573   cmds::GetVertexAttribfv cmd;
1574   cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, kInvalidSharedMemoryId, 0);
1575   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1576   EXPECT_EQ(0u, result->size);
1577 }
1578
1579 TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_1) {
1580   EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
1581   SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
1582   cmds::GetVertexAttribfv::Result* result =
1583       static_cast<cmds::GetVertexAttribfv::Result*>(shared_memory_address_);
1584   result->size = 0;
1585   cmds::GetVertexAttribfv cmd;
1586   cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
1587            kInvalidSharedMemoryOffset);
1588   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1589   EXPECT_EQ(0u, result->size);
1590 }
1591
1592 TEST_P(GLES2DecoderTest1, GetVertexAttribivValidArgs) {
1593   SpecializedSetup<cmds::GetVertexAttribiv, 0>(true);
1594   typedef cmds::GetVertexAttribiv::Result Result;
1595   Result* result = static_cast<Result*>(shared_memory_address_);
1596   result->size = 0;
1597   cmds::GetVertexAttribiv cmd;
1598   cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
1599            shared_memory_offset_);
1600   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1601   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
1602                 GL_VERTEX_ATTRIB_ARRAY_NORMALIZED),
1603             result->GetNumResults());
1604   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1605 }
1606
1607 TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_0) {
1608   EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
1609   SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
1610   cmds::GetVertexAttribiv::Result* result =
1611       static_cast<cmds::GetVertexAttribiv::Result*>(shared_memory_address_);
1612   result->size = 0;
1613   cmds::GetVertexAttribiv cmd;
1614   cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, kInvalidSharedMemoryId, 0);
1615   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1616   EXPECT_EQ(0u, result->size);
1617 }
1618
1619 TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_1) {
1620   EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
1621   SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
1622   cmds::GetVertexAttribiv::Result* result =
1623       static_cast<cmds::GetVertexAttribiv::Result*>(shared_memory_address_);
1624   result->size = 0;
1625   cmds::GetVertexAttribiv cmd;
1626   cmd.Init(1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, shared_memory_id_,
1627            kInvalidSharedMemoryOffset);
1628   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1629   EXPECT_EQ(0u, result->size);
1630 }
1631 // TODO(gman): GetVertexAttribPointerv
1632
1633 TEST_P(GLES2DecoderTest1, HintValidArgs) {
1634   EXPECT_CALL(*gl_, Hint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST));
1635   SpecializedSetup<cmds::Hint, 0>(true);
1636   cmds::Hint cmd;
1637   cmd.Init(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);
1638   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1639   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1640 }
1641
1642 TEST_P(GLES2DecoderTest1, HintInvalidArgs0_0) {
1643   EXPECT_CALL(*gl_, Hint(_, _)).Times(0);
1644   SpecializedSetup<cmds::Hint, 0>(false);
1645   cmds::Hint cmd;
1646   cmd.Init(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1647   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1648   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1649 }
1650
1651 TEST_P(GLES2DecoderTest1, IsBufferValidArgs) {
1652   SpecializedSetup<cmds::IsBuffer, 0>(true);
1653   cmds::IsBuffer cmd;
1654   cmd.Init(client_buffer_id_, shared_memory_id_, shared_memory_offset_);
1655   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1656   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1657 }
1658
1659 TEST_P(GLES2DecoderTest1, IsBufferInvalidArgsBadSharedMemoryId) {
1660   SpecializedSetup<cmds::IsBuffer, 0>(false);
1661   cmds::IsBuffer cmd;
1662   cmd.Init(client_buffer_id_, kInvalidSharedMemoryId, shared_memory_offset_);
1663   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1664   cmd.Init(client_buffer_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
1665   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1666 }
1667
1668 TEST_P(GLES2DecoderTest1, IsEnabledValidArgs) {
1669   SpecializedSetup<cmds::IsEnabled, 0>(true);
1670   cmds::IsEnabled cmd;
1671   cmd.Init(GL_BLEND, shared_memory_id_, shared_memory_offset_);
1672   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1673   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1674 }
1675
1676 TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgs0_0) {
1677   EXPECT_CALL(*gl_, IsEnabled(_)).Times(0);
1678   SpecializedSetup<cmds::IsEnabled, 0>(false);
1679   cmds::IsEnabled cmd;
1680   cmd.Init(GL_CLIP_PLANE0, shared_memory_id_, shared_memory_offset_);
1681   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1682   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1683 }
1684
1685 TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgs0_1) {
1686   EXPECT_CALL(*gl_, IsEnabled(_)).Times(0);
1687   SpecializedSetup<cmds::IsEnabled, 0>(false);
1688   cmds::IsEnabled cmd;
1689   cmd.Init(GL_POINT_SPRITE, shared_memory_id_, shared_memory_offset_);
1690   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1691   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1692 }
1693
1694 TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgsBadSharedMemoryId) {
1695   SpecializedSetup<cmds::IsEnabled, 0>(false);
1696   cmds::IsEnabled cmd;
1697   cmd.Init(GL_BLEND, kInvalidSharedMemoryId, shared_memory_offset_);
1698   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1699   cmd.Init(GL_BLEND, shared_memory_id_, kInvalidSharedMemoryOffset);
1700   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1701 }
1702
1703 TEST_P(GLES2DecoderTest1, IsFramebufferValidArgs) {
1704   SpecializedSetup<cmds::IsFramebuffer, 0>(true);
1705   cmds::IsFramebuffer cmd;
1706   cmd.Init(client_framebuffer_id_, shared_memory_id_, shared_memory_offset_);
1707   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1708   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1709 }
1710
1711 TEST_P(GLES2DecoderTest1, IsFramebufferInvalidArgsBadSharedMemoryId) {
1712   SpecializedSetup<cmds::IsFramebuffer, 0>(false);
1713   cmds::IsFramebuffer cmd;
1714   cmd.Init(client_framebuffer_id_, kInvalidSharedMemoryId,
1715            shared_memory_offset_);
1716   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1717   cmd.Init(client_framebuffer_id_, shared_memory_id_,
1718            kInvalidSharedMemoryOffset);
1719   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1720 }
1721
1722 TEST_P(GLES2DecoderTest1, IsProgramValidArgs) {
1723   SpecializedSetup<cmds::IsProgram, 0>(true);
1724   cmds::IsProgram cmd;
1725   cmd.Init(client_program_id_, shared_memory_id_, shared_memory_offset_);
1726   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1727   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1728 }
1729
1730 TEST_P(GLES2DecoderTest1, IsProgramInvalidArgsBadSharedMemoryId) {
1731   SpecializedSetup<cmds::IsProgram, 0>(false);
1732   cmds::IsProgram cmd;
1733   cmd.Init(client_program_id_, kInvalidSharedMemoryId, shared_memory_offset_);
1734   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1735   cmd.Init(client_program_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
1736   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1737 }
1738
1739 TEST_P(GLES2DecoderTest1, IsRenderbufferValidArgs) {
1740   SpecializedSetup<cmds::IsRenderbuffer, 0>(true);
1741   cmds::IsRenderbuffer cmd;
1742   cmd.Init(client_renderbuffer_id_, shared_memory_id_, shared_memory_offset_);
1743   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1744   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1745 }
1746
1747 TEST_P(GLES2DecoderTest1, IsRenderbufferInvalidArgsBadSharedMemoryId) {
1748   SpecializedSetup<cmds::IsRenderbuffer, 0>(false);
1749   cmds::IsRenderbuffer cmd;
1750   cmd.Init(client_renderbuffer_id_, kInvalidSharedMemoryId,
1751            shared_memory_offset_);
1752   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1753   cmd.Init(client_renderbuffer_id_, shared_memory_id_,
1754            kInvalidSharedMemoryOffset);
1755   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1756 }
1757
1758 TEST_P(GLES2DecoderTest1, IsShaderValidArgs) {
1759   SpecializedSetup<cmds::IsShader, 0>(true);
1760   cmds::IsShader cmd;
1761   cmd.Init(client_shader_id_, shared_memory_id_, shared_memory_offset_);
1762   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1763   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1764 }
1765
1766 TEST_P(GLES2DecoderTest1, IsShaderInvalidArgsBadSharedMemoryId) {
1767   SpecializedSetup<cmds::IsShader, 0>(false);
1768   cmds::IsShader cmd;
1769   cmd.Init(client_shader_id_, kInvalidSharedMemoryId, shared_memory_offset_);
1770   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1771   cmd.Init(client_shader_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
1772   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1773 }
1774
1775 TEST_P(GLES2DecoderTest1, IsTextureValidArgs) {
1776   SpecializedSetup<cmds::IsTexture, 0>(true);
1777   cmds::IsTexture cmd;
1778   cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
1779   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1780   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1781 }
1782
1783 TEST_P(GLES2DecoderTest1, IsTextureInvalidArgsBadSharedMemoryId) {
1784   SpecializedSetup<cmds::IsTexture, 0>(false);
1785   cmds::IsTexture cmd;
1786   cmd.Init(client_texture_id_, kInvalidSharedMemoryId, shared_memory_offset_);
1787   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1788   cmd.Init(client_texture_id_, shared_memory_id_, kInvalidSharedMemoryOffset);
1789   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
1790 }
1791
1792 TEST_P(GLES2DecoderTest1, LineWidthValidArgs) {
1793   EXPECT_CALL(*gl_, LineWidth(0.5f));
1794   SpecializedSetup<cmds::LineWidth, 0>(true);
1795   cmds::LineWidth cmd;
1796   cmd.Init(0.5f);
1797   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1798   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1799 }
1800
1801 TEST_P(GLES2DecoderTest1, LineWidthInvalidValue0_0) {
1802   SpecializedSetup<cmds::LineWidth, 0>(false);
1803   cmds::LineWidth cmd;
1804   cmd.Init(0.0f);
1805   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1806   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1807 }
1808
1809 TEST_P(GLES2DecoderTest1, LineWidthNaNValue0) {
1810   SpecializedSetup<cmds::LineWidth, 0>(false);
1811   cmds::LineWidth cmd;
1812   cmd.Init(nanf(""));
1813   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1814   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1815 }
1816
1817 TEST_P(GLES2DecoderTest1, LinkProgramValidArgs) {
1818   EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId));
1819   SpecializedSetup<cmds::LinkProgram, 0>(true);
1820   cmds::LinkProgram cmd;
1821   cmd.Init(client_program_id_);
1822   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1823   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1824 }
1825 // TODO(gman): PixelStorei
1826
1827 TEST_P(GLES2DecoderTest1, PolygonOffsetValidArgs) {
1828   EXPECT_CALL(*gl_, PolygonOffset(1, 2));
1829   SpecializedSetup<cmds::PolygonOffset, 0>(true);
1830   cmds::PolygonOffset cmd;
1831   cmd.Init(1, 2);
1832   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1833   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1834 }
1835 // TODO(gman): ReadPixels
1836
1837 // TODO(gman): ReleaseShaderCompiler
1838
1839 TEST_P(GLES2DecoderTest1, RenderbufferStorageValidArgs) {
1840   SpecializedSetup<cmds::RenderbufferStorage, 0>(true);
1841   cmds::RenderbufferStorage cmd;
1842   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, 4);
1843   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1844   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1845 }
1846
1847 TEST_P(GLES2DecoderTest1, RenderbufferStorageInvalidArgs0_0) {
1848   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
1849   SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
1850   cmds::RenderbufferStorage cmd;
1851   cmd.Init(GL_FRAMEBUFFER, GL_RGBA4, 3, 4);
1852   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1853   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1854 }
1855
1856 TEST_P(GLES2DecoderTest1, RenderbufferStorageInvalidArgs2_0) {
1857   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
1858   SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
1859   cmds::RenderbufferStorage cmd;
1860   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, -1, 4);
1861   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1862   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1863 }
1864
1865 TEST_P(GLES2DecoderTest1, RenderbufferStorageInvalidArgs3_0) {
1866   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
1867   SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
1868   cmds::RenderbufferStorage cmd;
1869   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, -1);
1870   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1871   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1872 }
1873
1874 TEST_P(GLES2DecoderTest1, SampleCoverageValidArgs) {
1875   EXPECT_CALL(*gl_, SampleCoverage(1, true));
1876   SpecializedSetup<cmds::SampleCoverage, 0>(true);
1877   cmds::SampleCoverage cmd;
1878   cmd.Init(1, true);
1879   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1880   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1881 }
1882 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_1_AUTOGEN_H_