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