| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 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 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" |
| 6 |
| 7 #include "base/command_line.h" |
| 8 #include "base/strings/string_number_conversions.h" |
| 9 #include "gpu/command_buffer/common/gles2_cmd_format.h" |
| 10 #include "gpu/command_buffer/common/gles2_cmd_utils.h" |
| 11 #include "gpu/command_buffer/common/id_allocator.h" |
| 12 #include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h" |
| 13 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h" |
| 14 #include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h" |
| 15 #include "gpu/command_buffer/service/cmd_buffer_engine.h" |
| 16 #include "gpu/command_buffer/service/context_group.h" |
| 17 #include "gpu/command_buffer/service/context_state.h" |
| 18 #include "gpu/command_buffer/service/gl_surface_mock.h" |
| 19 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h" |
| 20 |
| 21 #include "gpu/command_buffer/service/gpu_switches.h" |
| 22 #include "gpu/command_buffer/service/image_manager.h" |
| 23 #include "gpu/command_buffer/service/mailbox_manager.h" |
| 24 #include "gpu/command_buffer/service/mocks.h" |
| 25 #include "gpu/command_buffer/service/program_manager.h" |
| 26 #include "gpu/command_buffer/service/test_helper.h" |
| 27 #include "testing/gtest/include/gtest/gtest.h" |
| 28 #include "ui/gl/gl_implementation.h" |
| 29 #include "ui/gl/gl_mock.h" |
| 30 #include "ui/gl/gl_surface_stub.h" |
| 31 |
| 32 #if !defined(GL_DEPTH24_STENCIL8) |
| 33 #define GL_DEPTH24_STENCIL8 0x88F0 |
| 34 #endif |
| 35 |
| 36 using ::gfx::MockGLInterface; |
| 37 using ::testing::_; |
| 38 using ::testing::DoAll; |
| 39 using ::testing::InSequence; |
| 40 using ::testing::Invoke; |
| 41 using ::testing::MatcherCast; |
| 42 using ::testing::Mock; |
| 43 using ::testing::Pointee; |
| 44 using ::testing::Return; |
| 45 using ::testing::SaveArg; |
| 46 using ::testing::SetArrayArgument; |
| 47 using ::testing::SetArgumentPointee; |
| 48 using ::testing::SetArgPointee; |
| 49 using ::testing::StrEq; |
| 50 using ::testing::StrictMock; |
| 51 |
| 52 namespace gpu { |
| 53 namespace gles2 { |
| 54 |
| 55 using namespace cmds; |
| 56 |
| 57 TEST_F(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) { |
| 58 const uint32 kBucketId = 123; |
| 59 GetProgramInfoCHROMIUM cmd; |
| 60 cmd.Init(client_program_id_, kBucketId); |
| 61 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 62 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 63 EXPECT_GT(bucket->size(), 0u); |
| 64 } |
| 65 |
| 66 TEST_F(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) { |
| 67 const uint32 kBucketId = 123; |
| 68 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 69 EXPECT_TRUE(bucket == NULL); |
| 70 GetProgramInfoCHROMIUM cmd; |
| 71 cmd.Init(kInvalidClientId, kBucketId); |
| 72 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 73 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 74 bucket = decoder_->GetBucket(kBucketId); |
| 75 ASSERT_TRUE(bucket != NULL); |
| 76 EXPECT_EQ(sizeof(ProgramInfoHeader), bucket->size()); |
| 77 ProgramInfoHeader* info = |
| 78 bucket->GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader)); |
| 79 ASSERT_TRUE(info != 0); |
| 80 EXPECT_EQ(0u, info->link_status); |
| 81 EXPECT_EQ(0u, info->num_attribs); |
| 82 EXPECT_EQ(0u, info->num_uniforms); |
| 83 } |
| 84 |
| 85 TEST_F(GLES2DecoderWithShaderTest, GetUniformivSucceeds) { |
| 86 GetUniformiv::Result* result = |
| 87 static_cast<GetUniformiv::Result*>(shared_memory_address_); |
| 88 result->size = 0; |
| 89 GetUniformiv cmd; |
| 90 cmd.Init(client_program_id_, |
| 91 kUniform2FakeLocation, |
| 92 kSharedMemoryId, |
| 93 kSharedMemoryOffset); |
| 94 EXPECT_CALL(*gl_, GetUniformiv(kServiceProgramId, kUniform2RealLocation, _)) |
| 95 .Times(1); |
| 96 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 97 EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type), |
| 98 result->size); |
| 99 } |
| 100 |
| 101 TEST_F(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) { |
| 102 GetUniformiv::Result* result = |
| 103 static_cast<GetUniformiv::Result*>(shared_memory_address_); |
| 104 result->size = 0; |
| 105 GetUniformiv cmd; |
| 106 cmd.Init(client_program_id_, |
| 107 kUniform2ElementFakeLocation, |
| 108 kSharedMemoryId, |
| 109 kSharedMemoryOffset); |
| 110 EXPECT_CALL(*gl_, |
| 111 GetUniformiv(kServiceProgramId, kUniform2ElementRealLocation, _)) |
| 112 .Times(1); |
| 113 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 114 EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type), |
| 115 result->size); |
| 116 } |
| 117 |
| 118 TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) { |
| 119 GetUniformiv::Result* result = |
| 120 static_cast<GetUniformiv::Result*>(shared_memory_address_); |
| 121 result->size = 0; |
| 122 GetUniformiv cmd; |
| 123 // non-existant program |
| 124 cmd.Init(kInvalidClientId, |
| 125 kUniform2FakeLocation, |
| 126 kSharedMemoryId, |
| 127 kSharedMemoryOffset); |
| 128 EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0); |
| 129 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 130 EXPECT_EQ(0U, result->size); |
| 131 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 132 // Valid id that is not a program. The GL spec requires a different error for |
| 133 // this case. |
| 134 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 135 result->size = kInitialResult; |
| 136 cmd.Init(client_shader_id_, |
| 137 kUniform2FakeLocation, |
| 138 kSharedMemoryId, |
| 139 kSharedMemoryOffset); |
| 140 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 141 EXPECT_EQ(0U, result->size); |
| 142 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 143 #endif // GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 144 // Unlinked program |
| 145 EXPECT_CALL(*gl_, CreateProgram()) |
| 146 .Times(1) |
| 147 .WillOnce(Return(kNewServiceId)) |
| 148 .RetiresOnSaturation(); |
| 149 CreateProgram cmd2; |
| 150 cmd2.Init(kNewClientId); |
| 151 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); |
| 152 result->size = kInitialResult; |
| 153 cmd.Init(kNewClientId, |
| 154 kUniform2FakeLocation, |
| 155 kSharedMemoryId, |
| 156 kSharedMemoryOffset); |
| 157 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 158 EXPECT_EQ(0U, result->size); |
| 159 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 160 } |
| 161 |
| 162 TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadLocationFails) { |
| 163 GetUniformiv::Result* result = |
| 164 static_cast<GetUniformiv::Result*>(shared_memory_address_); |
| 165 result->size = 0; |
| 166 GetUniformiv cmd; |
| 167 // invalid location |
| 168 cmd.Init(client_program_id_, |
| 169 kInvalidUniformLocation, |
| 170 kSharedMemoryId, |
| 171 kSharedMemoryOffset); |
| 172 EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0); |
| 173 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 174 EXPECT_EQ(0U, result->size); |
| 175 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 176 } |
| 177 |
| 178 TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) { |
| 179 GetUniformiv cmd; |
| 180 cmd.Init(client_program_id_, |
| 181 kUniform2FakeLocation, |
| 182 kInvalidSharedMemoryId, |
| 183 kSharedMemoryOffset); |
| 184 EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0); |
| 185 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 186 cmd.Init(client_program_id_, |
| 187 kUniform2FakeLocation, |
| 188 kSharedMemoryId, |
| 189 kInvalidSharedMemoryOffset); |
| 190 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 191 }; |
| 192 |
| 193 TEST_F(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) { |
| 194 GetUniformfv::Result* result = |
| 195 static_cast<GetUniformfv::Result*>(shared_memory_address_); |
| 196 result->size = 0; |
| 197 GetUniformfv cmd; |
| 198 cmd.Init(client_program_id_, |
| 199 kUniform2FakeLocation, |
| 200 kSharedMemoryId, |
| 201 kSharedMemoryOffset); |
| 202 EXPECT_CALL(*gl_, GetUniformfv(kServiceProgramId, kUniform2RealLocation, _)) |
| 203 .Times(1); |
| 204 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 205 EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type), |
| 206 result->size); |
| 207 } |
| 208 |
| 209 TEST_F(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) { |
| 210 GetUniformfv::Result* result = |
| 211 static_cast<GetUniformfv::Result*>(shared_memory_address_); |
| 212 result->size = 0; |
| 213 GetUniformfv cmd; |
| 214 cmd.Init(client_program_id_, |
| 215 kUniform2ElementFakeLocation, |
| 216 kSharedMemoryId, |
| 217 kSharedMemoryOffset); |
| 218 EXPECT_CALL(*gl_, |
| 219 GetUniformfv(kServiceProgramId, kUniform2ElementRealLocation, _)) |
| 220 .Times(1); |
| 221 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 222 EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type), |
| 223 result->size); |
| 224 } |
| 225 |
| 226 TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) { |
| 227 GetUniformfv::Result* result = |
| 228 static_cast<GetUniformfv::Result*>(shared_memory_address_); |
| 229 result->size = 0; |
| 230 GetUniformfv cmd; |
| 231 // non-existant program |
| 232 cmd.Init(kInvalidClientId, |
| 233 kUniform2FakeLocation, |
| 234 kSharedMemoryId, |
| 235 kSharedMemoryOffset); |
| 236 EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0); |
| 237 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 238 EXPECT_EQ(0U, result->size); |
| 239 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 240 // Valid id that is not a program. The GL spec requires a different error for |
| 241 // this case. |
| 242 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 243 result->size = kInitialResult; |
| 244 cmd.Init(client_shader_id_, |
| 245 kUniform2FakeLocation, |
| 246 kSharedMemoryId, |
| 247 kSharedMemoryOffset); |
| 248 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 249 EXPECT_EQ(0U, result->size); |
| 250 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 251 #endif // GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 252 // Unlinked program |
| 253 EXPECT_CALL(*gl_, CreateProgram()) |
| 254 .Times(1) |
| 255 .WillOnce(Return(kNewServiceId)) |
| 256 .RetiresOnSaturation(); |
| 257 CreateProgram cmd2; |
| 258 cmd2.Init(kNewClientId); |
| 259 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2)); |
| 260 result->size = kInitialResult; |
| 261 cmd.Init(kNewClientId, |
| 262 kUniform2FakeLocation, |
| 263 kSharedMemoryId, |
| 264 kSharedMemoryOffset); |
| 265 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 266 EXPECT_EQ(0U, result->size); |
| 267 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 268 } |
| 269 |
| 270 TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadLocationFails) { |
| 271 GetUniformfv::Result* result = |
| 272 static_cast<GetUniformfv::Result*>(shared_memory_address_); |
| 273 result->size = 0; |
| 274 GetUniformfv cmd; |
| 275 // invalid location |
| 276 cmd.Init(client_program_id_, |
| 277 kInvalidUniformLocation, |
| 278 kSharedMemoryId, |
| 279 kSharedMemoryOffset); |
| 280 EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0); |
| 281 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 282 EXPECT_EQ(0U, result->size); |
| 283 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 284 } |
| 285 |
| 286 TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) { |
| 287 GetUniformfv cmd; |
| 288 cmd.Init(client_program_id_, |
| 289 kUniform2FakeLocation, |
| 290 kInvalidSharedMemoryId, |
| 291 kSharedMemoryOffset); |
| 292 EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0); |
| 293 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 294 cmd.Init(client_program_id_, |
| 295 kUniform2FakeLocation, |
| 296 kSharedMemoryId, |
| 297 kInvalidSharedMemoryOffset); |
| 298 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 299 }; |
| 300 |
| 301 TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) { |
| 302 GetAttachedShaders cmd; |
| 303 typedef GetAttachedShaders::Result Result; |
| 304 Result* result = static_cast<Result*>(shared_memory_address_); |
| 305 result->size = 0; |
| 306 EXPECT_CALL(*gl_, GetAttachedShaders(kServiceProgramId, 1, _, _)).WillOnce( |
| 307 DoAll(SetArgumentPointee<2>(1), SetArgumentPointee<3>(kServiceShaderId))); |
| 308 cmd.Init(client_program_id_, |
| 309 shared_memory_id_, |
| 310 shared_memory_offset_, |
| 311 Result::ComputeSize(1)); |
| 312 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 313 EXPECT_EQ(1, result->GetNumResults()); |
| 314 EXPECT_EQ(client_shader_id_, result->GetData()[0]); |
| 315 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 316 } |
| 317 |
| 318 TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersResultNotInitFail) { |
| 319 GetAttachedShaders cmd; |
| 320 typedef GetAttachedShaders::Result Result; |
| 321 Result* result = static_cast<Result*>(shared_memory_address_); |
| 322 result->size = 1; |
| 323 EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0); |
| 324 cmd.Init(client_program_id_, |
| 325 shared_memory_id_, |
| 326 shared_memory_offset_, |
| 327 Result::ComputeSize(1)); |
| 328 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 329 } |
| 330 |
| 331 TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersBadProgramFails) { |
| 332 GetAttachedShaders cmd; |
| 333 typedef GetAttachedShaders::Result Result; |
| 334 Result* result = static_cast<Result*>(shared_memory_address_); |
| 335 result->size = 0; |
| 336 EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0); |
| 337 cmd.Init(kInvalidClientId, |
| 338 shared_memory_id_, |
| 339 shared_memory_offset_, |
| 340 Result::ComputeSize(1)); |
| 341 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 342 EXPECT_EQ(0U, result->size); |
| 343 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 344 } |
| 345 |
| 346 TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersBadSharedMemoryFails) { |
| 347 GetAttachedShaders cmd; |
| 348 typedef GetAttachedShaders::Result Result; |
| 349 cmd.Init(client_program_id_, |
| 350 kInvalidSharedMemoryId, |
| 351 shared_memory_offset_, |
| 352 Result::ComputeSize(1)); |
| 353 EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0); |
| 354 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 355 cmd.Init(client_program_id_, |
| 356 shared_memory_id_, |
| 357 kInvalidSharedMemoryOffset, |
| 358 Result::ComputeSize(1)); |
| 359 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 360 } |
| 361 |
| 362 TEST_F(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) { |
| 363 ScopedGLImplementationSetter gl_impl(::gfx::kGLImplementationEGLGLES2); |
| 364 GetShaderPrecisionFormat cmd; |
| 365 typedef GetShaderPrecisionFormat::Result Result; |
| 366 Result* result = static_cast<Result*>(shared_memory_address_); |
| 367 result->success = 0; |
| 368 const GLint range[2] = {62, 62}; |
| 369 const GLint precision = 16; |
| 370 EXPECT_CALL(*gl_, GetShaderPrecisionFormat(_, _, _, _)) |
| 371 .WillOnce(DoAll(SetArrayArgument<2>(range, range + 2), |
| 372 SetArgumentPointee<3>(precision))) |
| 373 .RetiresOnSaturation(); |
| 374 cmd.Init(GL_VERTEX_SHADER, |
| 375 GL_HIGH_FLOAT, |
| 376 shared_memory_id_, |
| 377 shared_memory_offset_); |
| 378 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 379 EXPECT_NE(0, result->success); |
| 380 EXPECT_EQ(range[0], result->min_range); |
| 381 EXPECT_EQ(range[1], result->max_range); |
| 382 EXPECT_EQ(precision, result->precision); |
| 383 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 384 } |
| 385 |
| 386 TEST_F(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatResultNotInitFails) { |
| 387 GetShaderPrecisionFormat cmd; |
| 388 typedef GetShaderPrecisionFormat::Result Result; |
| 389 Result* result = static_cast<Result*>(shared_memory_address_); |
| 390 result->success = 1; |
| 391 // NOTE: GL might not be called. There is no Desktop OpenGL equivalent |
| 392 cmd.Init(GL_VERTEX_SHADER, |
| 393 GL_HIGH_FLOAT, |
| 394 shared_memory_id_, |
| 395 shared_memory_offset_); |
| 396 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 397 } |
| 398 |
| 399 TEST_F(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatBadArgsFails) { |
| 400 typedef GetShaderPrecisionFormat::Result Result; |
| 401 Result* result = static_cast<Result*>(shared_memory_address_); |
| 402 result->success = 0; |
| 403 GetShaderPrecisionFormat cmd; |
| 404 cmd.Init( |
| 405 GL_TEXTURE_2D, GL_HIGH_FLOAT, shared_memory_id_, shared_memory_offset_); |
| 406 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 407 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); |
| 408 result->success = 0; |
| 409 cmd.Init(GL_VERTEX_SHADER, |
| 410 GL_TEXTURE_2D, |
| 411 shared_memory_id_, |
| 412 shared_memory_offset_); |
| 413 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 414 EXPECT_EQ(GL_INVALID_ENUM, GetGLError()); |
| 415 } |
| 416 |
| 417 TEST_F(GLES2DecoderWithShaderTest, |
| 418 GetShaderPrecisionFormatBadSharedMemoryFails) { |
| 419 GetShaderPrecisionFormat cmd; |
| 420 cmd.Init(GL_VERTEX_SHADER, |
| 421 GL_HIGH_FLOAT, |
| 422 kInvalidSharedMemoryId, |
| 423 shared_memory_offset_); |
| 424 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 425 cmd.Init(GL_VERTEX_SHADER, |
| 426 GL_TEXTURE_2D, |
| 427 shared_memory_id_, |
| 428 kInvalidSharedMemoryOffset); |
| 429 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 430 } |
| 431 |
| 432 TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) { |
| 433 const GLuint kUniformIndex = 1; |
| 434 const uint32 kBucketId = 123; |
| 435 GetActiveUniform cmd; |
| 436 typedef GetActiveUniform::Result Result; |
| 437 Result* result = static_cast<Result*>(shared_memory_address_); |
| 438 result->success = 0; |
| 439 cmd.Init(client_program_id_, |
| 440 kUniformIndex, |
| 441 kBucketId, |
| 442 shared_memory_id_, |
| 443 shared_memory_offset_); |
| 444 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 445 EXPECT_NE(0, result->success); |
| 446 EXPECT_EQ(kUniform2Size, result->size); |
| 447 EXPECT_EQ(kUniform2Type, result->type); |
| 448 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 449 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 450 ASSERT_TRUE(bucket != NULL); |
| 451 EXPECT_EQ( |
| 452 0, |
| 453 memcmp( |
| 454 bucket->GetData(0, bucket->size()), kUniform2Name, bucket->size())); |
| 455 } |
| 456 |
| 457 TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) { |
| 458 const GLuint kUniformIndex = 1; |
| 459 const uint32 kBucketId = 123; |
| 460 GetActiveUniform cmd; |
| 461 typedef GetActiveUniform::Result Result; |
| 462 Result* result = static_cast<Result*>(shared_memory_address_); |
| 463 result->success = 1; |
| 464 cmd.Init(client_program_id_, |
| 465 kUniformIndex, |
| 466 kBucketId, |
| 467 shared_memory_id_, |
| 468 shared_memory_offset_); |
| 469 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 470 } |
| 471 |
| 472 TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) { |
| 473 const GLuint kUniformIndex = 1; |
| 474 const uint32 kBucketId = 123; |
| 475 GetActiveUniform cmd; |
| 476 typedef GetActiveUniform::Result Result; |
| 477 Result* result = static_cast<Result*>(shared_memory_address_); |
| 478 result->success = 0; |
| 479 cmd.Init(kInvalidClientId, |
| 480 kUniformIndex, |
| 481 kBucketId, |
| 482 shared_memory_id_, |
| 483 shared_memory_offset_); |
| 484 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 485 EXPECT_EQ(0, result->success); |
| 486 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 487 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 488 result->success = 0; |
| 489 cmd.Init(client_shader_id_, |
| 490 kUniformIndex, |
| 491 kBucketId, |
| 492 shared_memory_id_, |
| 493 shared_memory_offset_); |
| 494 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 495 EXPECT_EQ(0, result->success); |
| 496 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 497 #endif // GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 498 } |
| 499 |
| 500 TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) { |
| 501 const uint32 kBucketId = 123; |
| 502 GetActiveUniform cmd; |
| 503 typedef GetActiveUniform::Result Result; |
| 504 Result* result = static_cast<Result*>(shared_memory_address_); |
| 505 result->success = 0; |
| 506 cmd.Init(client_program_id_, |
| 507 kBadUniformIndex, |
| 508 kBucketId, |
| 509 shared_memory_id_, |
| 510 shared_memory_offset_); |
| 511 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 512 EXPECT_EQ(0, result->success); |
| 513 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 514 } |
| 515 |
| 516 TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) { |
| 517 const GLuint kUniformIndex = 1; |
| 518 const uint32 kBucketId = 123; |
| 519 GetActiveUniform cmd; |
| 520 cmd.Init(client_program_id_, |
| 521 kUniformIndex, |
| 522 kBucketId, |
| 523 kInvalidSharedMemoryId, |
| 524 shared_memory_offset_); |
| 525 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 526 cmd.Init(client_program_id_, |
| 527 kUniformIndex, |
| 528 kBucketId, |
| 529 shared_memory_id_, |
| 530 kInvalidSharedMemoryOffset); |
| 531 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 532 } |
| 533 |
| 534 TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) { |
| 535 const GLuint kAttribIndex = 1; |
| 536 const uint32 kBucketId = 123; |
| 537 GetActiveAttrib cmd; |
| 538 typedef GetActiveAttrib::Result Result; |
| 539 Result* result = static_cast<Result*>(shared_memory_address_); |
| 540 result->success = 0; |
| 541 cmd.Init(client_program_id_, |
| 542 kAttribIndex, |
| 543 kBucketId, |
| 544 shared_memory_id_, |
| 545 shared_memory_offset_); |
| 546 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 547 EXPECT_NE(0, result->success); |
| 548 EXPECT_EQ(kAttrib2Size, result->size); |
| 549 EXPECT_EQ(kAttrib2Type, result->type); |
| 550 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 551 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 552 ASSERT_TRUE(bucket != NULL); |
| 553 EXPECT_EQ( |
| 554 0, |
| 555 memcmp(bucket->GetData(0, bucket->size()), kAttrib2Name, bucket->size())); |
| 556 } |
| 557 |
| 558 TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) { |
| 559 const GLuint kAttribIndex = 1; |
| 560 const uint32 kBucketId = 123; |
| 561 GetActiveAttrib cmd; |
| 562 typedef GetActiveAttrib::Result Result; |
| 563 Result* result = static_cast<Result*>(shared_memory_address_); |
| 564 result->success = 1; |
| 565 cmd.Init(client_program_id_, |
| 566 kAttribIndex, |
| 567 kBucketId, |
| 568 shared_memory_id_, |
| 569 shared_memory_offset_); |
| 570 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 571 } |
| 572 |
| 573 TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) { |
| 574 const GLuint kAttribIndex = 1; |
| 575 const uint32 kBucketId = 123; |
| 576 GetActiveAttrib cmd; |
| 577 typedef GetActiveAttrib::Result Result; |
| 578 Result* result = static_cast<Result*>(shared_memory_address_); |
| 579 result->success = 0; |
| 580 cmd.Init(kInvalidClientId, |
| 581 kAttribIndex, |
| 582 kBucketId, |
| 583 shared_memory_id_, |
| 584 shared_memory_offset_); |
| 585 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 586 EXPECT_EQ(0, result->success); |
| 587 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 588 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 589 result->success = 0; |
| 590 cmd.Init(client_shader_id_, |
| 591 kAttribIndex, |
| 592 kBucketId, |
| 593 shared_memory_id_, |
| 594 shared_memory_offset_); |
| 595 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 596 EXPECT_EQ(0, result->success); |
| 597 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 598 #endif // GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 599 } |
| 600 |
| 601 TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) { |
| 602 const uint32 kBucketId = 123; |
| 603 GetActiveAttrib cmd; |
| 604 typedef GetActiveAttrib::Result Result; |
| 605 Result* result = static_cast<Result*>(shared_memory_address_); |
| 606 result->success = 0; |
| 607 cmd.Init(client_program_id_, |
| 608 kBadAttribIndex, |
| 609 kBucketId, |
| 610 shared_memory_id_, |
| 611 shared_memory_offset_); |
| 612 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 613 EXPECT_EQ(0, result->success); |
| 614 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 615 } |
| 616 |
| 617 TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) { |
| 618 const GLuint kAttribIndex = 1; |
| 619 const uint32 kBucketId = 123; |
| 620 GetActiveAttrib cmd; |
| 621 cmd.Init(client_program_id_, |
| 622 kAttribIndex, |
| 623 kBucketId, |
| 624 kInvalidSharedMemoryId, |
| 625 shared_memory_offset_); |
| 626 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 627 cmd.Init(client_program_id_, |
| 628 kAttribIndex, |
| 629 kBucketId, |
| 630 shared_memory_id_, |
| 631 kInvalidSharedMemoryOffset); |
| 632 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 633 } |
| 634 |
| 635 TEST_F(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) { |
| 636 const char* kInfo = "hello"; |
| 637 const uint32 kBucketId = 123; |
| 638 CompileShader compile_cmd; |
| 639 GetShaderInfoLog cmd; |
| 640 EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _)); |
| 641 EXPECT_CALL(*gl_, CompileShader(kServiceShaderId)); |
| 642 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _)) |
| 643 .WillOnce(SetArgumentPointee<2>(GL_FALSE)) |
| 644 .RetiresOnSaturation(); |
| 645 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _)) |
| 646 .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1)) |
| 647 .RetiresOnSaturation(); |
| 648 EXPECT_CALL(*gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _)) |
| 649 .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)), |
| 650 SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1))); |
| 651 compile_cmd.Init(client_shader_id_); |
| 652 cmd.Init(client_shader_id_, kBucketId); |
| 653 EXPECT_EQ(error::kNoError, ExecuteCmd(compile_cmd)); |
| 654 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 655 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 656 ASSERT_TRUE(bucket != NULL); |
| 657 EXPECT_EQ(strlen(kInfo) + 1, bucket->size()); |
| 658 EXPECT_EQ(0, |
| 659 memcmp(bucket->GetData(0, bucket->size()), kInfo, bucket->size())); |
| 660 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 661 } |
| 662 |
| 663 TEST_F(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) { |
| 664 const uint32 kBucketId = 123; |
| 665 GetShaderInfoLog cmd; |
| 666 cmd.Init(kInvalidClientId, kBucketId); |
| 667 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 668 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 669 } |
| 670 |
| 671 TEST_F(GLES2DecoderTest, CompileShaderValidArgs) { |
| 672 EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _)); |
| 673 EXPECT_CALL(*gl_, CompileShader(kServiceShaderId)); |
| 674 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _)) |
| 675 .WillOnce(SetArgumentPointee<2>(GL_TRUE)) |
| 676 .RetiresOnSaturation(); |
| 677 CompileShader cmd; |
| 678 cmd.Init(client_shader_id_); |
| 679 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 680 } |
| 681 |
| 682 TEST_F(GLES2DecoderTest, CompileShaderInvalidArgs) { |
| 683 CompileShader cmd; |
| 684 cmd.Init(kInvalidClientId); |
| 685 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 686 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 687 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 688 cmd.Init(client_program_id_); |
| 689 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 690 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 691 #endif // GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 692 } |
| 693 |
| 694 TEST_F(GLES2DecoderTest, ShaderSourceAndGetShaderSourceValidArgs) { |
| 695 const uint32 kBucketId = 123; |
| 696 const char kSource[] = "hello"; |
| 697 const uint32 kSourceSize = sizeof(kSource) - 1; |
| 698 memcpy(shared_memory_address_, kSource, kSourceSize); |
| 699 ShaderSource cmd; |
| 700 cmd.Init( |
| 701 client_shader_id_, kSharedMemoryId, kSharedMemoryOffset, kSourceSize); |
| 702 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 703 memset(shared_memory_address_, 0, kSourceSize); |
| 704 GetShaderSource get_cmd; |
| 705 get_cmd.Init(client_shader_id_, kBucketId); |
| 706 EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd)); |
| 707 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 708 ASSERT_TRUE(bucket != NULL); |
| 709 EXPECT_EQ(kSourceSize + 1, bucket->size()); |
| 710 EXPECT_EQ( |
| 711 0, memcmp(bucket->GetData(0, bucket->size()), kSource, bucket->size())); |
| 712 } |
| 713 |
| 714 TEST_F(GLES2DecoderTest, ShaderSourceInvalidArgs) { |
| 715 const char kSource[] = "hello"; |
| 716 const uint32 kSourceSize = sizeof(kSource) - 1; |
| 717 memcpy(shared_memory_address_, kSource, kSourceSize); |
| 718 ShaderSource cmd; |
| 719 cmd.Init(kInvalidClientId, kSharedMemoryId, kSharedMemoryOffset, kSourceSize); |
| 720 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 721 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 722 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 723 cmd.Init( |
| 724 client_program_id_, kSharedMemoryId, kSharedMemoryOffset, kSourceSize); |
| 725 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 726 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 727 #endif // GLES2_TEST_SHADER_VS_PROGRAM_IDS |
| 728 cmd.Init(client_shader_id_, |
| 729 kInvalidSharedMemoryId, |
| 730 kSharedMemoryOffset, |
| 731 kSourceSize); |
| 732 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 733 cmd.Init(client_shader_id_, |
| 734 kSharedMemoryId, |
| 735 kInvalidSharedMemoryOffset, |
| 736 kSourceSize); |
| 737 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 738 cmd.Init(client_shader_id_, |
| 739 kSharedMemoryId, |
| 740 kSharedMemoryOffset, |
| 741 kSharedBufferSize); |
| 742 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 743 } |
| 744 |
| 745 TEST_F(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) { |
| 746 const uint32 kInBucketId = 123; |
| 747 const uint32 kOutBucketId = 125; |
| 748 const char kSource[] = "hello"; |
| 749 const uint32 kSourceSize = sizeof(kSource) - 1; |
| 750 SetBucketAsCString(kInBucketId, kSource); |
| 751 ShaderSourceBucket cmd; |
| 752 cmd.Init(client_shader_id_, kInBucketId); |
| 753 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 754 ClearSharedMemory(); |
| 755 GetShaderSource get_cmd; |
| 756 get_cmd.Init(client_shader_id_, kOutBucketId); |
| 757 EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd)); |
| 758 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kOutBucketId); |
| 759 ASSERT_TRUE(bucket != NULL); |
| 760 EXPECT_EQ(kSourceSize + 1, bucket->size()); |
| 761 EXPECT_EQ( |
| 762 0, memcmp(bucket->GetData(0, bucket->size()), kSource, bucket->size())); |
| 763 } |
| 764 |
| 765 TEST_F(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) { |
| 766 const uint32 kBucketId = 123; |
| 767 const char kSource[] = "hello"; |
| 768 const uint32 kSourceSize = sizeof(kSource) - 1; |
| 769 memcpy(shared_memory_address_, kSource, kSourceSize); |
| 770 ShaderSourceBucket cmd; |
| 771 // Test no bucket. |
| 772 cmd.Init(client_texture_id_, kBucketId); |
| 773 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 774 // Test invalid client. |
| 775 SetBucketAsCString(kBucketId, kSource); |
| 776 cmd.Init(kInvalidClientId, kBucketId); |
| 777 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 778 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 779 } |
| 780 |
| 781 TEST_F(GLES2DecoderTest, ShaderSourceStripComments) { |
| 782 const uint32 kInBucketId = 123; |
| 783 const char kSource[] = "hello/*te\ast*/world//a\ab"; |
| 784 SetBucketAsCString(kInBucketId, kSource); |
| 785 ShaderSourceBucket cmd; |
| 786 cmd.Init(client_shader_id_, kInBucketId); |
| 787 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 788 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 789 } |
| 790 |
| 791 TEST_F(GLES2DecoderWithShaderTest, Uniform1iValidArgs) { |
| 792 EXPECT_CALL(*gl_, Uniform1i(kUniform1RealLocation, 2)); |
| 793 Uniform1i cmd; |
| 794 cmd.Init(kUniform1FakeLocation, 2); |
| 795 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 796 } |
| 797 |
| 798 TEST_F(GLES2DecoderWithShaderTest, Uniform1ivValidArgs) { |
| 799 EXPECT_CALL( |
| 800 *gl_, |
| 801 Uniform1iv(kUniform1RealLocation, |
| 802 1, |
| 803 reinterpret_cast<const GLint*>(shared_memory_address_))); |
| 804 Uniform1iv cmd; |
| 805 cmd.Init(kUniform1FakeLocation, 1, shared_memory_id_, shared_memory_offset_); |
| 806 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 807 } |
| 808 |
| 809 TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_0) { |
| 810 EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0); |
| 811 Uniform1iv cmd; |
| 812 cmd.Init(kUniform1FakeLocation, 1, kInvalidSharedMemoryId, 0); |
| 813 EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd)); |
| 814 } |
| 815 |
| 816 TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_1) { |
| 817 EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0); |
| 818 Uniform1iv cmd; |
| 819 cmd.Init( |
| 820 kUniform1FakeLocation, 1, shared_memory_id_, kInvalidSharedMemoryOffset); |
| 821 EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd)); |
| 822 } |
| 823 |
| 824 TEST_F(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) { |
| 825 Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>(); |
| 826 EXPECT_CALL(*gl_, |
| 827 Uniform1iv(kUniform1RealLocation, |
| 828 1, |
| 829 reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd)))); |
| 830 GLint temp[1 * 2] = { |
| 831 0, |
| 832 }; |
| 833 cmd.Init(kUniform1FakeLocation, 1, &temp[0]); |
| 834 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp))); |
| 835 } |
| 836 |
| 837 TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) { |
| 838 EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0); |
| 839 Uniform1iv cmd; |
| 840 cmd.Init(kUniform1FakeLocation, 2, shared_memory_id_, shared_memory_offset_); |
| 841 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 842 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 843 } |
| 844 |
| 845 TEST_F(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) { |
| 846 EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0); |
| 847 Uniform1iv cmd; |
| 848 cmd.Init(kUniform1FakeLocation, 0, shared_memory_id_, shared_memory_offset_); |
| 849 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 850 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 851 } |
| 852 |
| 853 TEST_F(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) { |
| 854 EXPECT_CALL(*gl_, Uniform1i(_, _)).Times(0); |
| 855 Uniform1i cmd; |
| 856 cmd.Init(kUniform1FakeLocation, kNumTextureUnits); |
| 857 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 858 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 859 } |
| 860 |
| 861 TEST_F(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) { |
| 862 EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0); |
| 863 Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>(); |
| 864 GLint temp[] = {kNumTextureUnits}; |
| 865 cmd.Init(kUniform1FakeLocation, 1, &temp[0]); |
| 866 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp))); |
| 867 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 868 } |
| 869 |
| 870 TEST_F(GLES2DecoderTest, BindAttribLocation) { |
| 871 const GLint kLocation = 2; |
| 872 const char* kName = "testing"; |
| 873 const uint32 kNameSize = strlen(kName); |
| 874 EXPECT_CALL(*gl_, |
| 875 BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName))) |
| 876 .Times(1); |
| 877 memcpy(shared_memory_address_, kName, kNameSize); |
| 878 BindAttribLocation cmd; |
| 879 cmd.Init(client_program_id_, |
| 880 kLocation, |
| 881 kSharedMemoryId, |
| 882 kSharedMemoryOffset, |
| 883 kNameSize); |
| 884 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 885 } |
| 886 |
| 887 TEST_F(GLES2DecoderTest, BindAttribLocationInvalidArgs) { |
| 888 const GLint kLocation = 2; |
| 889 const char* kName = "testing"; |
| 890 const char* kBadName = "test\aing"; |
| 891 const uint32 kNameSize = strlen(kName); |
| 892 const uint32 kBadNameSize = strlen(kBadName); |
| 893 EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0); |
| 894 memcpy(shared_memory_address_, kName, kNameSize); |
| 895 BindAttribLocation cmd; |
| 896 cmd.Init(kInvalidClientId, |
| 897 kLocation, |
| 898 kSharedMemoryId, |
| 899 kSharedMemoryOffset, |
| 900 kNameSize); |
| 901 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 902 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 903 cmd.Init(client_program_id_, |
| 904 kLocation, |
| 905 kInvalidSharedMemoryId, |
| 906 kSharedMemoryOffset, |
| 907 kNameSize); |
| 908 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 909 cmd.Init(client_program_id_, |
| 910 kLocation, |
| 911 kSharedMemoryId, |
| 912 kInvalidSharedMemoryOffset, |
| 913 kNameSize); |
| 914 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 915 cmd.Init(client_program_id_, |
| 916 kLocation, |
| 917 kSharedMemoryId, |
| 918 kSharedMemoryOffset, |
| 919 kSharedBufferSize); |
| 920 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 921 memcpy(shared_memory_address_, kBadName, kBadNameSize); |
| 922 cmd.Init(client_program_id_, |
| 923 kLocation, |
| 924 kSharedMemoryId, |
| 925 kSharedMemoryOffset, |
| 926 kBadNameSize); |
| 927 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 928 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 929 } |
| 930 |
| 931 TEST_F(GLES2DecoderTest, BindAttribLocationBucket) { |
| 932 const uint32 kBucketId = 123; |
| 933 const GLint kLocation = 2; |
| 934 const char* kName = "testing"; |
| 935 EXPECT_CALL(*gl_, |
| 936 BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName))) |
| 937 .Times(1); |
| 938 SetBucketAsCString(kBucketId, kName); |
| 939 BindAttribLocationBucket cmd; |
| 940 cmd.Init(client_program_id_, kLocation, kBucketId); |
| 941 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 942 } |
| 943 |
| 944 TEST_F(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) { |
| 945 const uint32 kBucketId = 123; |
| 946 const GLint kLocation = 2; |
| 947 const char* kName = "testing"; |
| 948 EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0); |
| 949 BindAttribLocationBucket cmd; |
| 950 // check bucket does not exist. |
| 951 cmd.Init(client_program_id_, kLocation, kBucketId); |
| 952 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 953 // check bucket is empty. |
| 954 SetBucketAsCString(kBucketId, NULL); |
| 955 cmd.Init(client_program_id_, kLocation, kBucketId); |
| 956 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 957 // Check bad program id |
| 958 SetBucketAsCString(kBucketId, kName); |
| 959 cmd.Init(kInvalidClientId, kLocation, kBucketId); |
| 960 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 961 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 962 } |
| 963 |
| 964 TEST_F(GLES2DecoderWithShaderTest, GetAttribLocation) { |
| 965 const uint32 kNameSize = strlen(kAttrib2Name); |
| 966 const char* kNonExistentName = "foobar"; |
| 967 const uint32 kNonExistentNameSize = strlen(kNonExistentName); |
| 968 typedef GetAttribLocation::Result Result; |
| 969 Result* result = GetSharedMemoryAs<Result*>(); |
| 970 *result = -1; |
| 971 char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result)); |
| 972 const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result); |
| 973 memcpy(name, kAttrib2Name, kNameSize); |
| 974 GetAttribLocation cmd; |
| 975 cmd.Init(client_program_id_, |
| 976 kSharedMemoryId, |
| 977 kNameOffset, |
| 978 kSharedMemoryId, |
| 979 kSharedMemoryOffset, |
| 980 kNameSize); |
| 981 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 982 EXPECT_EQ(kAttrib2Location, *result); |
| 983 *result = -1; |
| 984 memcpy(name, kNonExistentName, kNonExistentNameSize); |
| 985 cmd.Init(client_program_id_, |
| 986 kSharedMemoryId, |
| 987 kNameOffset, |
| 988 kSharedMemoryId, |
| 989 kSharedMemoryOffset, |
| 990 kNonExistentNameSize); |
| 991 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 992 EXPECT_EQ(-1, *result); |
| 993 } |
| 994 |
| 995 TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) { |
| 996 const uint32 kNameSize = strlen(kAttrib2Name); |
| 997 const char* kBadName = "foo\abar"; |
| 998 const uint32 kBadNameSize = strlen(kBadName); |
| 999 typedef GetAttribLocation::Result Result; |
| 1000 Result* result = GetSharedMemoryAs<Result*>(); |
| 1001 *result = -1; |
| 1002 char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result)); |
| 1003 const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result); |
| 1004 memcpy(name, kAttrib2Name, kNameSize); |
| 1005 GetAttribLocation cmd; |
| 1006 cmd.Init(kInvalidClientId, |
| 1007 kSharedMemoryId, |
| 1008 kNameOffset, |
| 1009 kSharedMemoryId, |
| 1010 kSharedMemoryOffset, |
| 1011 kNameSize); |
| 1012 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1013 EXPECT_EQ(-1, *result); |
| 1014 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1015 *result = -1; |
| 1016 cmd.Init(client_program_id_, |
| 1017 kInvalidSharedMemoryId, |
| 1018 kNameOffset, |
| 1019 kSharedMemoryId, |
| 1020 kSharedMemoryOffset, |
| 1021 kNameSize); |
| 1022 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1023 EXPECT_EQ(-1, *result); |
| 1024 cmd.Init(client_program_id_, |
| 1025 kSharedMemoryId, |
| 1026 kInvalidSharedMemoryOffset, |
| 1027 kSharedMemoryId, |
| 1028 kSharedMemoryOffset, |
| 1029 kNameSize); |
| 1030 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1031 EXPECT_EQ(-1, *result); |
| 1032 cmd.Init(client_program_id_, |
| 1033 kSharedMemoryId, |
| 1034 kNameOffset, |
| 1035 kInvalidSharedMemoryId, |
| 1036 kSharedMemoryOffset, |
| 1037 kNameSize); |
| 1038 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1039 EXPECT_EQ(-1, *result); |
| 1040 cmd.Init(client_program_id_, |
| 1041 kSharedMemoryId, |
| 1042 kNameOffset, |
| 1043 kSharedMemoryId, |
| 1044 kInvalidSharedMemoryOffset, |
| 1045 kNameSize); |
| 1046 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1047 EXPECT_EQ(-1, *result); |
| 1048 cmd.Init(client_program_id_, |
| 1049 kSharedMemoryId, |
| 1050 kNameOffset, |
| 1051 kSharedMemoryId, |
| 1052 kSharedMemoryOffset, |
| 1053 kSharedBufferSize); |
| 1054 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1055 EXPECT_EQ(-1, *result); |
| 1056 memcpy(name, kBadName, kBadNameSize); |
| 1057 cmd.Init(client_program_id_, |
| 1058 kSharedMemoryId, |
| 1059 kNameOffset, |
| 1060 kSharedMemoryId, |
| 1061 kSharedMemoryOffset, |
| 1062 kBadNameSize); |
| 1063 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1064 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1065 } |
| 1066 |
| 1067 TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationBucket) { |
| 1068 const uint32 kBucketId = 123; |
| 1069 const char* kNonExistentName = "foobar"; |
| 1070 typedef GetAttribLocationBucket::Result Result; |
| 1071 Result* result = GetSharedMemoryAs<Result*>(); |
| 1072 SetBucketAsCString(kBucketId, kAttrib2Name); |
| 1073 *result = -1; |
| 1074 GetAttribLocationBucket cmd; |
| 1075 cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1076 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1077 EXPECT_EQ(kAttrib2Location, *result); |
| 1078 SetBucketAsCString(kBucketId, kNonExistentName); |
| 1079 *result = -1; |
| 1080 cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1081 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1082 EXPECT_EQ(-1, *result); |
| 1083 } |
| 1084 |
| 1085 TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) { |
| 1086 const uint32 kBucketId = 123; |
| 1087 typedef GetAttribLocationBucket::Result Result; |
| 1088 Result* result = GetSharedMemoryAs<Result*>(); |
| 1089 *result = -1; |
| 1090 GetAttribLocationBucket cmd; |
| 1091 // Check no bucket |
| 1092 cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1093 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1094 EXPECT_EQ(-1, *result); |
| 1095 // Check bad program id. |
| 1096 SetBucketAsCString(kBucketId, kAttrib2Name); |
| 1097 cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1098 *result = -1; |
| 1099 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1100 EXPECT_EQ(-1, *result); |
| 1101 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1102 // Check bad memory |
| 1103 cmd.Init(client_program_id_, |
| 1104 kBucketId, |
| 1105 kInvalidSharedMemoryId, |
| 1106 kSharedMemoryOffset); |
| 1107 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1108 cmd.Init(client_program_id_, |
| 1109 kBucketId, |
| 1110 kSharedMemoryId, |
| 1111 kInvalidSharedMemoryOffset); |
| 1112 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1113 } |
| 1114 |
| 1115 TEST_F(GLES2DecoderWithShaderTest, GetUniformLocation) { |
| 1116 const uint32 kNameSize = strlen(kUniform2Name); |
| 1117 const char* kNonExistentName = "foobar"; |
| 1118 const uint32 kNonExistentNameSize = strlen(kNonExistentName); |
| 1119 typedef GetUniformLocation::Result Result; |
| 1120 Result* result = GetSharedMemoryAs<Result*>(); |
| 1121 *result = -1; |
| 1122 char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result)); |
| 1123 const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result); |
| 1124 memcpy(name, kUniform2Name, kNameSize); |
| 1125 GetUniformLocation cmd; |
| 1126 cmd.Init(client_program_id_, |
| 1127 kSharedMemoryId, |
| 1128 kNameOffset, |
| 1129 kSharedMemoryId, |
| 1130 kSharedMemoryOffset, |
| 1131 kNameSize); |
| 1132 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1133 EXPECT_EQ(kUniform2FakeLocation, *result); |
| 1134 memcpy(name, kNonExistentName, kNonExistentNameSize); |
| 1135 *result = -1; |
| 1136 cmd.Init(client_program_id_, |
| 1137 kSharedMemoryId, |
| 1138 kNameOffset, |
| 1139 kSharedMemoryId, |
| 1140 kSharedMemoryOffset, |
| 1141 kNonExistentNameSize); |
| 1142 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1143 EXPECT_EQ(-1, *result); |
| 1144 } |
| 1145 |
| 1146 TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) { |
| 1147 const uint32 kNameSize = strlen(kUniform2Name); |
| 1148 const char* kBadName = "foo\abar"; |
| 1149 const uint32 kBadNameSize = strlen(kBadName); |
| 1150 typedef GetUniformLocation::Result Result; |
| 1151 Result* result = GetSharedMemoryAs<Result*>(); |
| 1152 *result = -1; |
| 1153 char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result)); |
| 1154 const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result); |
| 1155 memcpy(name, kUniform2Name, kNameSize); |
| 1156 GetUniformLocation cmd; |
| 1157 cmd.Init(kInvalidClientId, |
| 1158 kSharedMemoryId, |
| 1159 kNameOffset, |
| 1160 kSharedMemoryId, |
| 1161 kSharedMemoryOffset, |
| 1162 kNameSize); |
| 1163 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1164 EXPECT_EQ(-1, *result); |
| 1165 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1166 *result = -1; |
| 1167 cmd.Init(client_program_id_, |
| 1168 kInvalidSharedMemoryId, |
| 1169 kNameOffset, |
| 1170 kSharedMemoryId, |
| 1171 kSharedMemoryOffset, |
| 1172 kNameSize); |
| 1173 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1174 EXPECT_EQ(-1, *result); |
| 1175 cmd.Init(client_program_id_, |
| 1176 kSharedMemoryId, |
| 1177 kInvalidSharedMemoryOffset, |
| 1178 kSharedMemoryId, |
| 1179 kSharedMemoryOffset, |
| 1180 kNameSize); |
| 1181 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1182 EXPECT_EQ(-1, *result); |
| 1183 cmd.Init(client_program_id_, |
| 1184 kSharedMemoryId, |
| 1185 kNameOffset, |
| 1186 kInvalidSharedMemoryId, |
| 1187 kSharedMemoryOffset, |
| 1188 kNameSize); |
| 1189 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1190 EXPECT_EQ(-1, *result); |
| 1191 cmd.Init(client_program_id_, |
| 1192 kSharedMemoryId, |
| 1193 kNameOffset, |
| 1194 kSharedMemoryId, |
| 1195 kInvalidSharedMemoryOffset, |
| 1196 kNameSize); |
| 1197 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1198 EXPECT_EQ(-1, *result); |
| 1199 cmd.Init(client_program_id_, |
| 1200 kSharedMemoryId, |
| 1201 kNameOffset, |
| 1202 kSharedMemoryId, |
| 1203 kSharedMemoryOffset, |
| 1204 kSharedBufferSize); |
| 1205 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1206 EXPECT_EQ(-1, *result); |
| 1207 memcpy(name, kBadName, kBadNameSize); |
| 1208 cmd.Init(client_program_id_, |
| 1209 kSharedMemoryId, |
| 1210 kNameOffset, |
| 1211 kSharedMemoryId, |
| 1212 kSharedMemoryOffset, |
| 1213 kBadNameSize); |
| 1214 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1215 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1216 } |
| 1217 |
| 1218 TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationBucket) { |
| 1219 const uint32 kBucketId = 123; |
| 1220 const char* kNonExistentName = "foobar"; |
| 1221 typedef GetUniformLocationBucket::Result Result; |
| 1222 Result* result = GetSharedMemoryAs<Result*>(); |
| 1223 SetBucketAsCString(kBucketId, kUniform2Name); |
| 1224 *result = -1; |
| 1225 GetUniformLocationBucket cmd; |
| 1226 cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1227 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1228 EXPECT_EQ(kUniform2FakeLocation, *result); |
| 1229 SetBucketAsCString(kBucketId, kNonExistentName); |
| 1230 *result = -1; |
| 1231 cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1232 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1233 EXPECT_EQ(-1, *result); |
| 1234 } |
| 1235 |
| 1236 TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) { |
| 1237 const uint32 kBucketId = 123; |
| 1238 typedef GetUniformLocationBucket::Result Result; |
| 1239 Result* result = GetSharedMemoryAs<Result*>(); |
| 1240 *result = -1; |
| 1241 GetUniformLocationBucket cmd; |
| 1242 // Check no bucket |
| 1243 cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1244 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1245 EXPECT_EQ(-1, *result); |
| 1246 // Check bad program id. |
| 1247 SetBucketAsCString(kBucketId, kUniform2Name); |
| 1248 cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset); |
| 1249 *result = -1; |
| 1250 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1251 EXPECT_EQ(-1, *result); |
| 1252 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1253 // Check bad memory |
| 1254 cmd.Init(client_program_id_, |
| 1255 kBucketId, |
| 1256 kInvalidSharedMemoryId, |
| 1257 kSharedMemoryOffset); |
| 1258 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1259 cmd.Init(client_program_id_, |
| 1260 kBucketId, |
| 1261 kSharedMemoryId, |
| 1262 kInvalidSharedMemoryOffset); |
| 1263 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1264 } |
| 1265 |
| 1266 TEST_F(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUM) { |
| 1267 const GLint kLocation = 2; |
| 1268 const char* kName = "testing"; |
| 1269 const uint32 kNameSize = strlen(kName); |
| 1270 const char* kBadName1 = "gl_testing"; |
| 1271 const uint32 kBadName1Size = strlen(kBadName1); |
| 1272 const char* kBadName2 = "testing[1]"; |
| 1273 const uint32 kBadName2Size = strlen(kBadName2); |
| 1274 memcpy(shared_memory_address_, kName, kNameSize); |
| 1275 BindUniformLocationCHROMIUM cmd; |
| 1276 cmd.Init(client_program_id_, |
| 1277 kLocation, |
| 1278 kSharedMemoryId, |
| 1279 kSharedMemoryOffset, |
| 1280 kNameSize); |
| 1281 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1282 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 1283 // check negative location |
| 1284 memcpy(shared_memory_address_, kName, kNameSize); |
| 1285 cmd.Init( |
| 1286 client_program_id_, -1, kSharedMemoryId, kSharedMemoryOffset, kNameSize); |
| 1287 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1288 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1289 // check highest location |
| 1290 memcpy(shared_memory_address_, kName, kNameSize); |
| 1291 GLint kMaxLocation = |
| 1292 (kMaxFragmentUniformVectors + kMaxVertexUniformVectors) * 4 - 1; |
| 1293 cmd.Init(client_program_id_, |
| 1294 kMaxLocation, |
| 1295 kSharedMemoryId, |
| 1296 kSharedMemoryOffset, |
| 1297 kNameSize); |
| 1298 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1299 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 1300 // check too high location |
| 1301 memcpy(shared_memory_address_, kName, kNameSize); |
| 1302 cmd.Init(client_program_id_, |
| 1303 kMaxLocation + 1, |
| 1304 kSharedMemoryId, |
| 1305 kSharedMemoryOffset, |
| 1306 kNameSize); |
| 1307 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1308 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1309 // check bad name "gl_..." |
| 1310 memcpy(shared_memory_address_, kBadName1, kBadName1Size); |
| 1311 cmd.Init(client_program_id_, |
| 1312 kLocation, |
| 1313 kSharedMemoryId, |
| 1314 kSharedMemoryOffset, |
| 1315 kBadName1Size); |
| 1316 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1317 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 1318 // check bad name "name[1]" non zero |
| 1319 memcpy(shared_memory_address_, kBadName2, kBadName2Size); |
| 1320 cmd.Init(client_program_id_, |
| 1321 kLocation, |
| 1322 kSharedMemoryId, |
| 1323 kSharedMemoryOffset, |
| 1324 kBadName2Size); |
| 1325 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1326 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1327 } |
| 1328 |
| 1329 TEST_F(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) { |
| 1330 CommandLine command_line(0, NULL); |
| 1331 command_line.AppendSwitchASCII( |
| 1332 switches::kGpuDriverBugWorkarounds, |
| 1333 base::IntToString(gpu::CLEAR_UNIFORMS_BEFORE_FIRST_PROGRAM_USE)); |
| 1334 InitState init; |
| 1335 init.gl_version = "3.0"; |
| 1336 init.has_alpha = true; |
| 1337 init.request_alpha = true; |
| 1338 init.bind_generates_resource = true; |
| 1339 InitDecoderWithCommandLine(init, &command_line); |
| 1340 { |
| 1341 static AttribInfo attribs[] = { |
| 1342 { |
| 1343 kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, |
| 1344 }, |
| 1345 { |
| 1346 kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, |
| 1347 }, |
| 1348 { |
| 1349 kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, |
| 1350 }, |
| 1351 }; |
| 1352 static UniformInfo uniforms[] = { |
| 1353 {kUniform1Name, kUniform1Size, kUniform1Type, kUniform1FakeLocation, |
| 1354 kUniform1RealLocation, kUniform1DesiredLocation}, |
| 1355 {kUniform2Name, kUniform2Size, kUniform2Type, kUniform2FakeLocation, |
| 1356 kUniform2RealLocation, kUniform2DesiredLocation}, |
| 1357 {kUniform3Name, kUniform3Size, kUniform3Type, kUniform3FakeLocation, |
| 1358 kUniform3RealLocation, kUniform3DesiredLocation}, |
| 1359 }; |
| 1360 SetupShader(attribs, |
| 1361 arraysize(attribs), |
| 1362 uniforms, |
| 1363 arraysize(uniforms), |
| 1364 client_program_id_, |
| 1365 kServiceProgramId, |
| 1366 client_vertex_shader_id_, |
| 1367 kServiceVertexShaderId, |
| 1368 client_fragment_shader_id_, |
| 1369 kServiceFragmentShaderId); |
| 1370 TestHelper::SetupExpectationsForClearingUniforms( |
| 1371 gl_.get(), uniforms, arraysize(uniforms)); |
| 1372 } |
| 1373 |
| 1374 { |
| 1375 EXPECT_CALL(*gl_, UseProgram(kServiceProgramId)) |
| 1376 .Times(1) |
| 1377 .RetiresOnSaturation(); |
| 1378 cmds::UseProgram cmd; |
| 1379 cmd.Init(client_program_id_); |
| 1380 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1381 } |
| 1382 } |
| 1383 |
| 1384 // TODO(gman): DeleteProgram |
| 1385 |
| 1386 // TODO(gman): UseProgram |
| 1387 |
| 1388 // TODO(gman): DeleteShader |
| 1389 |
| 1390 } // namespace gles2 |
| 1391 } // namespace gpu |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 268773006:
Refactor gles2_cmd_decoder_unittest.cc into components. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master