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