src/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h

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