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::GenQueriesEXTImmediate, 0>( 256 bool valid) { 257 if (!valid) { 258 // Make the client_query_id_ so that trying to make it again 259 // will fail. 260 cmds::GenQueriesEXTImmediate& cmd = 261 *GetImmediateAs<cmds::GenQueriesEXTImmediate>(); 262 cmd.Init(1, &client_query_id_); 263 EXPECT_EQ(error::kNoError, 264 ExecuteImmediateCmd(cmd, sizeof(client_query_id_))); 265 } 266 }; 267 268 template <> 269 void GLES2DecoderTestBase::SpecializedSetup<cmds::DeleteQueriesEXTImmediate, 0>( 270 bool valid) { 271 if (valid) { 272 // Make the client_query_id_ so that trying to delete it will succeed. 273 cmds::GenQueriesEXTImmediate& cmd = 274 *GetImmediateAs<cmds::GenQueriesEXTImmediate>(); 275 cmd.Init(1, &client_query_id_); 276 EXPECT_EQ(error::kNoError, 277 ExecuteImmediateCmd(cmd, sizeof(client_query_id_))); 278 } 279 }; 280 281 template <> 282 void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>( 283 bool /* valid */) { 284 const GLuint kClientVertexShaderId = 5001; 285 const GLuint kServiceVertexShaderId = 6001; 286 const GLuint kClientFragmentShaderId = 5002; 287 const GLuint kServiceFragmentShaderId = 6002; 288 DoCreateShader( 289 GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId); 290 DoCreateShader( 291 GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId); 292 293 TestHelper::SetShaderStates( 294 gl_.get(), GetShader(kClientVertexShaderId), true); 295 TestHelper::SetShaderStates( 296 gl_.get(), GetShader(kClientFragmentShaderId), true); 297 298 InSequence dummy; 299 EXPECT_CALL(*gl_, 300 AttachShader(kServiceProgramId, kServiceVertexShaderId)) 301 .Times(1) 302 .RetiresOnSaturation(); 303 EXPECT_CALL(*gl_, 304 AttachShader(kServiceProgramId, kServiceFragmentShaderId)) 305 .Times(1) 306 .RetiresOnSaturation(); 307 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) 308 .WillOnce(SetArgumentPointee<2>(1)); 309 EXPECT_CALL(*gl_, 310 GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _)) 311 .WillOnce(SetArgumentPointee<2>(0)) 312 .RetiresOnSaturation(); 313 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTES, _)) 314 .WillOnce(SetArgumentPointee<2>(0)); 315 EXPECT_CALL( 316 *gl_, 317 GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _)) 318 .WillOnce(SetArgumentPointee<2>(0)); 319 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _)) 320 .WillOnce(SetArgumentPointee<2>(0)); 321 EXPECT_CALL( 322 *gl_, 323 GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORM_MAX_LENGTH, _)) 324 .WillOnce(SetArgumentPointee<2>(0)); 325 326 cmds::AttachShader attach_cmd; 327 attach_cmd.Init(client_program_id_, kClientVertexShaderId); 328 EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd)); 329 330 attach_cmd.Init(client_program_id_, kClientFragmentShaderId); 331 EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd)); 332 }; 333 334 template <> 335 void GLES2DecoderTestBase::SpecializedSetup<cmds::UseProgram, 0>( 336 bool /* valid */) { 337 // Needs the same setup as LinkProgram. 338 SpecializedSetup<cmds::LinkProgram, 0>(false); 339 340 EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId)) 341 .Times(1) 342 .RetiresOnSaturation(); 343 344 cmds::LinkProgram link_cmd; 345 link_cmd.Init(client_program_id_); 346 EXPECT_EQ(error::kNoError, ExecuteCmd(link_cmd)); 347 }; 348 349 template <> 350 void GLES2DecoderTestBase::SpecializedSetup<cmds::ValidateProgram, 0>( 351 bool /* valid */) { 352 // Needs the same setup as LinkProgram. 353 SpecializedSetup<cmds::LinkProgram, 0>(false); 354 355 EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId)) 356 .Times(1) 357 .RetiresOnSaturation(); 358 359 cmds::LinkProgram link_cmd; 360 link_cmd.Init(client_program_id_); 361 EXPECT_EQ(error::kNoError, ExecuteCmd(link_cmd)); 362 363 EXPECT_CALL(*gl_, 364 GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _)) 365 .WillOnce(SetArgumentPointee<2>(0)) 366 .RetiresOnSaturation(); 367 }; 368 369 template <> 370 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1f, 0>( 371 bool /* valid */) { 372 SetupShaderForUniform(GL_FLOAT); 373 }; 374 375 template <> 376 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1fvImmediate, 0>( 377 bool /* valid */) { 378 SetupShaderForUniform(GL_FLOAT); 379 }; 380 381 template <> 382 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform1ivImmediate, 0>( 383 bool /* valid */) { 384 SetupShaderForUniform(GL_INT); 385 }; 386 387 template <> 388 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2f, 0>( 389 bool /* valid */) { 390 SetupShaderForUniform(GL_FLOAT_VEC2); 391 }; 392 393 template <> 394 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2i, 0>( 395 bool /* valid */) { 396 SetupShaderForUniform(GL_INT_VEC2); 397 }; 398 399 template <> 400 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2fvImmediate, 0>( 401 bool /* valid */) { 402 SetupShaderForUniform(GL_FLOAT_VEC2); 403 }; 404 405 template <> 406 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform2ivImmediate, 0>( 407 bool /* valid */) { 408 SetupShaderForUniform(GL_INT_VEC2); 409 }; 410 411 template <> 412 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3f, 0>( 413 bool /* valid */) { 414 SetupShaderForUniform(GL_FLOAT_VEC3); 415 }; 416 417 template <> 418 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3i, 0>( 419 bool /* valid */) { 420 SetupShaderForUniform(GL_INT_VEC3); 421 }; 422 423 template <> 424 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3fvImmediate, 0>( 425 bool /* valid */) { 426 SetupShaderForUniform(GL_FLOAT_VEC3); 427 }; 428 429 template <> 430 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform3ivImmediate, 0>( 431 bool /* valid */) { 432 SetupShaderForUniform(GL_INT_VEC3); 433 }; 434 435 template <> 436 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4f, 0>( 437 bool /* valid */) { 438 SetupShaderForUniform(GL_FLOAT_VEC4); 439 }; 440 441 template <> 442 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4i, 0>( 443 bool /* valid */) { 444 SetupShaderForUniform(GL_INT_VEC4); 445 }; 446 447 template <> 448 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4fvImmediate, 0>( 449 bool /* valid */) { 450 SetupShaderForUniform(GL_FLOAT_VEC4); 451 }; 452 453 template <> 454 void GLES2DecoderTestBase::SpecializedSetup<cmds::Uniform4ivImmediate, 0>( 455 bool /* valid */) { 456 SetupShaderForUniform(GL_INT_VEC4); 457 }; 458 459 template <> 460 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>( 461 bool /* valid */) { 462 SetupShaderForUniform(GL_FLOAT_MAT2); 463 }; 464 465 template <> 466 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix3fvImmediate, 0>( 467 bool /* valid */) { 468 SetupShaderForUniform(GL_FLOAT_MAT3); 469 }; 470 471 template <> 472 void GLES2DecoderTestBase::SpecializedSetup<cmds::UniformMatrix4fvImmediate, 0>( 473 bool /* valid */) { 474 SetupShaderForUniform(GL_FLOAT_MAT4); 475 }; 476 477 template <> 478 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterf, 0>( 479 bool /* valid */) { 480 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 481 }; 482 483 template <> 484 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameteri, 0>( 485 bool /* valid */) { 486 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 487 }; 488 489 template <> 490 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterfvImmediate, 0>( 491 bool /* valid */) { 492 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 493 }; 494 495 template <> 496 void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>( 497 bool /* valid */) { 498 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId); 499 }; 500 501 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h" 502 503 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT) { 504 TestAcceptedUniform(GL_INT, Program::kUniform1i); 505 } 506 507 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC2) { 508 TestAcceptedUniform(GL_INT_VEC2, Program::kUniform2i); 509 } 510 511 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC3) { 512 TestAcceptedUniform(GL_INT_VEC3, Program::kUniform3i); 513 } 514 515 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC4) { 516 TestAcceptedUniform(GL_INT_VEC4, Program::kUniform4i); 517 } 518 519 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL) { 520 TestAcceptedUniform(GL_BOOL, Program::kUniform1i | Program::kUniform1f); 521 } 522 523 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC2) { 524 TestAcceptedUniform(GL_BOOL_VEC2, Program::kUniform2i | Program::kUniform2f); 525 } 526 527 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC3) { 528 TestAcceptedUniform(GL_BOOL_VEC3, Program::kUniform3i | Program::kUniform3f); 529 } 530 531 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC4) { 532 TestAcceptedUniform(GL_BOOL_VEC4, Program::kUniform4i | Program::kUniform4f); 533 } 534 535 TEST_P(GLES2DecoderTest2, AcceptsUniformTypeFLOAT) { 536 TestAcceptedUniform(GL_FLOAT, Program::kUniform1f); 537 } 538 539 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC2) { 540 TestAcceptedUniform(GL_FLOAT_VEC2, Program::kUniform2f); 541 } 542 543 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC3) { 544 TestAcceptedUniform(GL_FLOAT_VEC3, Program::kUniform3f); 545 } 546 547 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC4) { 548 TestAcceptedUniform(GL_FLOAT_VEC4, Program::kUniform4f); 549 } 550 551 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2) { 552 TestAcceptedUniform(GL_FLOAT_MAT2, Program::kUniformMatrix2f); 553 } 554 555 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3) { 556 TestAcceptedUniform(GL_FLOAT_MAT3, Program::kUniformMatrix3f); 557 } 558 559 TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) { 560 TestAcceptedUniform(GL_FLOAT_MAT4, Program::kUniformMatrix4f); 561 } 562 563 } // namespace gles2 564 } // namespace gpu 565 566
