gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
   6
   7 #include "gpu/command_buffer/common/gles2_cmd_format.h"
   8 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
   9 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
  10 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
  11 #include "gpu/command_buffer/service/context_group.h"
  12 #include "gpu/command_buffer/service/program_manager.h"
  13 #include "gpu/command_buffer/service/test_helper.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "ui/gl/gl_mock.h"
  16
  17 using ::gfx::MockGLInterface;
  18 using ::testing::_;
  19 using ::testing::AnyNumber;
  20 using ::testing::DoAll;
  21 using ::testing::InSequence;
  22 using ::testing::MatcherCast;
  23 using ::testing::Pointee;
  24 using ::testing::Return;
  25 using ::testing::SetArrayArgument;
  26 using ::testing::SetArgumentPointee;
  27 using ::testing::StrEq;
  28
  29 namespace gpu {
  30 namespace gles2 {
  31
  32 class GLES2DecoderTest2 : public GLES2DecoderTestBase {
  33  public:
  34   GLES2DecoderTest2() { }
  35
  36   void TestAcceptedUniform(GLenum uniform_type, uint32 accepts_apis) {
  37     SetupShaderForUniform(uniform_type);
  38     bool valid_uniform = false;
  39
  40     EXPECT_CALL(*gl_, Uniform1i(1, _)).Times(AnyNumber());
  41     EXPECT_CALL(*gl_, Uniform1iv(1, _, _)).Times(AnyNumber());
  42     EXPECT_CALL(*gl_, Uniform2iv(1, _, _)).Times(AnyNumber());
  43     EXPECT_CALL(*gl_, Uniform3iv(1, _, _)).Times(AnyNumber());
  44     EXPECT_CALL(*gl_, Uniform4iv(1, _, _)).Times(AnyNumber());
  45     EXPECT_CALL(*gl_, Uniform1f(1, _)).Times(AnyNumber());
  46     EXPECT_CALL(*gl_, Uniform1fv(1, _, _)).Times(AnyNumber());
  47     EXPECT_CALL(*gl_, Uniform2fv(1, _, _)).Times(AnyNumber());
  48     EXPECT_CALL(*gl_, Uniform3fv(1, _, _)).Times(AnyNumber());
  49     EXPECT_CALL(*gl_, Uniform4fv(1, _, _)).Times(AnyNumber());
  50     EXPECT_CALL(*gl_, UniformMatrix2fv(1, _, _, _)).Times(AnyNumber());
  51     EXPECT_CALL(*gl_, UniformMatrix3fv(1, _, _, _)).Times(AnyNumber());
  52     EXPECT_CALL(*gl_, UniformMatrix4fv(1, _, _, _)).Times(AnyNumber());
  53
  54     {
  55       valid_uniform = accepts_apis & Program::kUniform1i;
  56       cmds::Uniform1i cmd;
  57       cmd.Init(1, 2);
  58       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  59       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
  60                 GetGLError());
  61     }
  62
  63     {
  64       valid_uniform = accepts_apis & Program::kUniform1i;
  65       cmds::Uniform1ivImmediate& cmd =
  66           *GetImmediateAs<cmds::Uniform1ivImmediate>();
  67       GLint data[2][1] = {{0}};
  68       cmd.Init(1, 2, &data[0][0]);
  69       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
  70       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
  71                 GetGLError());
  72     }
  73
  74     {
  75       valid_uniform = accepts_apis & Program::kUniform2i;
  76       cmds::Uniform2i cmd;
  77       cmd.Init(1, 2, 3);
  78       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  79       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
  80                 GetGLError());
  81     }
  82
  83     {
  84       valid_uniform = accepts_apis & Program::kUniform2i;
  85       cmds::Uniform2ivImmediate& cmd =
  86           *GetImmediateAs<cmds::Uniform2ivImmediate>();
  87       GLint data[2][2] = {{0}};
  88       cmd.Init(1, 2, &data[0][0]);
  89       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
  90       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
  91                 GetGLError());
  92     }
  93
  94     {
  95       valid_uniform = accepts_apis & Program::kUniform3i;
  96       cmds::Uniform3i cmd;
  97       cmd.Init(1, 2, 3, 4);
  98       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  99       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 100                 GetGLError());
 101     }
 102
 103     {
 104       valid_uniform = accepts_apis & Program::kUniform3i;
 105       cmds::Uniform3ivImmediate& cmd =
 106           *GetImmediateAs<cmds::Uniform3ivImmediate>();
 107       GLint data[2][3] = {{0}};
 108       cmd.Init(1, 2, &data[0][0]);
 109       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 110       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 111                 GetGLError());
 112     }
 113
 114     {
 115       valid_uniform = accepts_apis & Program::kUniform4i;
 116       cmds::Uniform4i cmd;
 117       cmd.Init(1, 2, 3, 4, 5);
 118       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 119       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 120                 GetGLError());
 121     }
 122
 123     {
 124       valid_uniform = accepts_apis & Program::kUniform4i;
 125       cmds::Uniform4ivImmediate& cmd =
 126           *GetImmediateAs<cmds::Uniform4ivImmediate>();
 127       GLint data[2][4] = {{0}};
 128       cmd.Init(1, 2, &data[0][0]);
 129       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 130       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 131                 GetGLError());
 132     }
 133
 134     ////////////////////
 135
 136     {
 137       valid_uniform = accepts_apis & Program::kUniform1f;
 138       cmds::Uniform1f cmd;
 139       cmd.Init(1, 2);
 140       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 141       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 142                 GetGLError());
 143     }
 144
 145     {
 146       valid_uniform = accepts_apis & Program::kUniform1f;
 147       cmds::Uniform1fvImmediate& cmd =
 148           *GetImmediateAs<cmds::Uniform1fvImmediate>();
 149       GLfloat data[2][1] = {{0.0f}};
 150       cmd.Init(1, 2, &data[0][0]);
 151       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 152       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 153                 GetGLError());
 154     }
 155
 156     {
 157       valid_uniform = accepts_apis & Program::kUniform2f;
 158       cmds::Uniform2f cmd;
 159       cmd.Init(1, 2, 3);
 160       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 161       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 162                 GetGLError());
 163     }
 164
 165     {
 166       valid_uniform = accepts_apis & Program::kUniform2f;
 167       cmds::Uniform2fvImmediate& cmd =
 168           *GetImmediateAs<cmds::Uniform2fvImmediate>();
 169       GLfloat data[2][2] = {{0.0f}};
 170       cmd.Init(1, 2, &data[0][0]);
 171       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 172       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 173                 GetGLError());
 174     }
 175
 176     {
 177       valid_uniform = accepts_apis & Program::kUniform3f;
 178       cmds::Uniform3f cmd;
 179       cmd.Init(1, 2, 3, 4);
 180       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 181       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 182                 GetGLError());
 183     }
 184
 185     {
 186       valid_uniform = accepts_apis & Program::kUniform3f;
 187       cmds::Uniform3fvImmediate& cmd =
 188           *GetImmediateAs<cmds::Uniform3fvImmediate>();
 189       GLfloat data[2][3] = {{0.0f}};
 190       cmd.Init(1, 2, &data[0][0]);
 191       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 192       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 193                 GetGLError());
 194     }
 195
 196     {
 197       valid_uniform = accepts_apis & Program::kUniform4f;
 198       cmds::Uniform4f cmd;
 199       cmd.Init(1, 2, 3, 4, 5);
 200       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 201       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 202                 GetGLError());
 203     }
 204
 205     {
 206       valid_uniform = accepts_apis & Program::kUniform4f;
 207       cmds::Uniform4fvImmediate& cmd =
 208           *GetImmediateAs<cmds::Uniform4fvImmediate>();
 209       GLfloat data[2][4] = {{0.0f}};
 210       cmd.Init(1, 2, &data[0][0]);
 211       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 212       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 213                 GetGLError());
 214     }
 215
 216     {
 217       valid_uniform = accepts_apis & Program::kUniformMatrix2f;
 218       cmds::UniformMatrix2fvImmediate& cmd =
 219           *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
 220       GLfloat data[2][2 * 2] = {{0.0f}};
 221
 222       cmd.Init(1, 2, &data[0][0]);
 223       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 224       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 225                 GetGLError());
 226     }
 227
 228     {
 229       valid_uniform = accepts_apis & Program::kUniformMatrix3f;
 230       cmds::UniformMatrix3fvImmediate& cmd =
 231           *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
 232       GLfloat data[2][3 * 3] = {{0.0f}};
 233       cmd.Init(1, 2, &data[0][0]);
 234       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 235       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 236                 GetGLError());
 237     }
 238
 239     {
 240       valid_uniform = accepts_apis & Program::kUniformMatrix4f;
 241       cmds::UniformMatrix4fvImmediate& cmd =
 242           *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
 243       GLfloat data[2][4 * 4] = {{0.0f}};
 244       cmd.Init(1, 2, &data[0][0]);
 245       EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(data)));
 246       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
 247                 GetGLError());
 248     }
 249   }
 250 };
 251
 252 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest2, ::testing::Bool());
 253
 254 template <>
 255 void GLES2DecoderTestBase::SpecializedSetup<cmds::RenderbufferStorage, 0>(
 256     bool valid) {
 257   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
 258                     kServiceRenderbufferId);
 259   if (valid) {
 260     EnsureRenderbufferBound(false);
 261     EXPECT_CALL(*gl_, GetError())
 262         .WillOnce(Return(GL_NO_ERROR))
 263         .RetiresOnSaturation();
 264     EXPECT_CALL(*gl_,
 265                 RenderbufferStorageEXT(GL_RENDERBUFFER, _, 3, 4))
 266         .Times(1)
 267         .RetiresOnSaturation();
 268     EXPECT_CALL(*gl_, GetError())
 269         .WillOnce(Return(GL_NO_ERROR))
 270         .RetiresOnSaturation();
 271   }
 272 }
 273
 274 template <>
 275 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXTImmediate, 0>(
 276     bool valid) {
 277   if (!valid) {
 278     // Make the client_query_id_ so that trying to make it again
 279     // will fail.
 280     cmds::GenQueriesEXTImmediate& cmd =
 281         *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
 282     cmd.Init(1, &client_query_id_);
 283     EXPECT_EQ(error::kNoError,
 284               ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
 285   }
 286 };
 287
 288 template <>
 289 void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXTImmediate, 0>(
 290     bool valid) {
 291   if (valid) {
 292     // Make the client_query_id_ so that trying to delete it will succeed.
 293     cmds::GenQueriesEXTImmediate& cmd =
 294         *GetImmediateAs<cmds::GenQueriesEXTImmediate>();
 295     cmd.Init(1, &client_query_id_);
 296     EXPECT_EQ(error::kNoError,
 297               ExecuteImmediateCmd(cmd, sizeof(client_query_id_)));
 298   }
 299 };
 300
 301 template <>
 302 void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(
 303     bool /* valid */) {
 304   const GLuint kClientVertexShaderId = 5001;
 305   const GLuint kServiceVertexShaderId = 6001;
 306   const GLuint kClientFragmentShaderId = 5002;
 307   const GLuint kServiceFragmentShaderId = 6002;
 308   DoCreateShader(
 309       GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId);
 310   DoCreateShader(
 311       GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId);
 312
 313   TestHelper::SetShaderStates(
 314       gl_.get(), GetShader(kClientVertexShaderId), true);
 315   TestHelper::SetShaderStates(
 316       gl_.get(), GetShader(kClientFragmentShaderId), true);
 317
 318   InSequence dummy;
 319   EXPECT_CALL(*gl_,
 320               AttachShader(kServiceProgramId, kServiceVertexShaderId))
 321       .Times(1)
 322       .RetiresOnSaturation();
 323   EXPECT_CALL(*gl_,
 324               AttachShader(kServiceProgramId, kServiceFragmentShaderId))
 325       .Times(1)
 326       .RetiresOnSaturation();
 327   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 328       .WillOnce(SetArgumentPointee<2>(1));
 329   EXPECT_CALL(*gl_,
 330       GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _))
 331       .WillOnce(SetArgumentPointee<2>(0))
 332       .RetiresOnSaturation();
 333   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTES, _))
 334       .WillOnce(SetArgumentPointee<2>(0));
 335   EXPECT_CALL(
 336       *gl_,
 337       GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
 338       .WillOnce(SetArgumentPointee<2>(0));
 339   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
 340       .WillOnce(SetArgumentPointee<2>(0));
 341   EXPECT_CALL(
 342       *gl_,
 343       GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORM_MAX_LENGTH, _))
 344       .WillOnce(SetArgumentPointee<2>(0));
 345
 346   cmds::AttachShader attach_cmd;
 347   attach_cmd.Init(client_program_id_, kClientVertexShaderId);
 348   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
 349
 350   attach_cmd.Init(client_program_id_, kClientFragmentShaderId);
 351   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
 352 };
 353
 354 template <>
 355 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1f, 0>(
 356     bool /* valid */) {
 357   SetupShaderForUniform(GL_FLOAT);
 358 };
 359
 360 template <>
 361 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fvImmediate, 0>(
 362     bool /* valid */) {
 363   SetupShaderForUniform(GL_FLOAT);
 364 };
 365
 366 template <>
 367 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1ivImmediate, 0>(
 368     bool /* valid */) {
 369   SetupShaderForUniform(GL_INT);
 370 };
 371
 372 template <>
 373 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2f, 0>(
 374     bool /* valid */) {
 375   SetupShaderForUniform(GL_FLOAT_VEC2);
 376 };
 377
 378 template <>
 379 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2i, 0>(
 380     bool /* valid */) {
 381   SetupShaderForUniform(GL_INT_VEC2);
 382 };
 383
 384 template <>
 385 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fvImmediate, 0>(
 386     bool /* valid */) {
 387   SetupShaderForUniform(GL_FLOAT_VEC2);
 388 };
 389
 390 template <>
 391 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2ivImmediate, 0>(
 392     bool /* valid */) {
 393   SetupShaderForUniform(GL_INT_VEC2);
 394 };
 395
 396 template <>
 397 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3f, 0>(
 398     bool /* valid */) {
 399   SetupShaderForUniform(GL_FLOAT_VEC3);
 400 };
 401
 402 template <>
 403 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3i, 0>(
 404     bool /* valid */) {
 405   SetupShaderForUniform(GL_INT_VEC3);
 406 };
 407
 408 template <>
 409 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fvImmediate, 0>(
 410     bool /* valid */) {
 411   SetupShaderForUniform(GL_FLOAT_VEC3);
 412 };
 413
 414 template <>
 415 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3ivImmediate, 0>(
 416     bool /* valid */) {
 417   SetupShaderForUniform(GL_INT_VEC3);
 418 };
 419
 420 template <>
 421 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4f, 0>(
 422     bool /* valid */) {
 423   SetupShaderForUniform(GL_FLOAT_VEC4);
 424 };
 425
 426 template <>
 427 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4i, 0>(
 428     bool /* valid */) {
 429   SetupShaderForUniform(GL_INT_VEC4);
 430 };
 431
 432 template <>
 433 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4fvImmediate, 0>(
 434     bool /* valid */) {
 435   SetupShaderForUniform(GL_FLOAT_VEC4);
 436 };
 437
 438 template <>
 439 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4ivImmediate, 0>(
 440     bool /* valid */) {
 441   SetupShaderForUniform(GL_INT_VEC4);
 442 };
 443
 444 template <>
 445 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(
 446     bool /* valid */) {
 447   SetupShaderForUniform(GL_FLOAT_MAT2);
 448 };
 449
 450 template <>
 451 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix3fvImmediate, 0>(
 452     bool /* valid */) {
 453   SetupShaderForUniform(GL_FLOAT_MAT3);
 454 };
 455
 456 template <>
 457 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix4fvImmediate, 0>(
 458     bool /* valid */) {
 459   SetupShaderForUniform(GL_FLOAT_MAT4);
 460 };
 461
 462 template <>
 463 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterf, 0>(
 464     bool /* valid */) {
 465   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 466 };
 467
 468 template <>
 469 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteri, 0>(
 470     bool /* valid */) {
 471   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 472 };
 473
 474 template <>
 475 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfvImmediate, 0>(
 476     bool /* valid */) {
 477   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 478 };
 479
 480 template <>
 481 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
 482     bool /* valid */) {
 483   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 484 };
 485
 486 template <>
 487 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribiv, 0>(
 488     bool valid) {
 489   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
 490   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
 491   if (valid) {
 492     EXPECT_CALL(*gl_, GetError())
 493         .WillOnce(Return(GL_NO_ERROR))
 494         .WillOnce(Return(GL_NO_ERROR))
 495         .RetiresOnSaturation();
 496   }
 497 };
 498
 499 template <>
 500 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribfv, 0>(
 501     bool valid) {
 502   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
 503   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
 504   if (valid) {
 505     EXPECT_CALL(*gl_, GetError())
 506         .WillOnce(Return(GL_NO_ERROR))
 507         .WillOnce(Return(GL_NO_ERROR))
 508         .RetiresOnSaturation();
 509   }
 510 };
 511
 512
 513 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h"
 514
 515 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT) {
 516   TestAcceptedUniform(GL_INT, Program::kUniform1i);
 517 }
 518
 519 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC2) {
 520   TestAcceptedUniform(GL_INT_VEC2, Program::kUniform2i);
 521 }
 522
 523 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC3) {
 524   TestAcceptedUniform(GL_INT_VEC3, Program::kUniform3i);
 525 }
 526
 527 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC4) {
 528   TestAcceptedUniform(GL_INT_VEC4, Program::kUniform4i);
 529 }
 530
 531 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL) {
 532   TestAcceptedUniform(GL_BOOL, Program::kUniform1i | Program::kUniform1f);
 533 }
 534
 535 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC2) {
 536   TestAcceptedUniform(GL_BOOL_VEC2, Program::kUniform2i | Program::kUniform2f);
 537 }
 538
 539 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC3) {
 540   TestAcceptedUniform(GL_BOOL_VEC3, Program::kUniform3i | Program::kUniform3f);
 541 }
 542
 543 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC4) {
 544   TestAcceptedUniform(GL_BOOL_VEC4, Program::kUniform4i | Program::kUniform4f);
 545 }
 546
 547 TEST_P(GLES2DecoderTest2, AcceptsUniformTypeFLOAT) {
 548   TestAcceptedUniform(GL_FLOAT, Program::kUniform1f);
 549 }
 550
 551 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC2) {
 552   TestAcceptedUniform(GL_FLOAT_VEC2, Program::kUniform2f);
 553 }
 554
 555 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC3) {
 556   TestAcceptedUniform(GL_FLOAT_VEC3, Program::kUniform3f);
 557 }
 558
 559 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC4) {
 560   TestAcceptedUniform(GL_FLOAT_VEC4, Program::kUniform4f);
 561 }
 562
 563 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2) {
 564   TestAcceptedUniform(GL_FLOAT_MAT2, Program::kUniformMatrix2f);
 565 }
 566
 567 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3) {
 568   TestAcceptedUniform(GL_FLOAT_MAT3, Program::kUniformMatrix3f);
 569 }
 570
 571 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) {
 572   TestAcceptedUniform(GL_FLOAT_MAT4, Program::kUniformMatrix4f);
 573 }
 574
 575 }  // namespace gles2
 576 }  // namespace gpu
 577