OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" | 5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" |
6 | 6 |
7 #include "base/command_line.h" | 7 #include "base/command_line.h" |
8 #include "base/strings/string_number_conversions.h" | 8 #include "base/strings/string_number_conversions.h" |
9 #include "gpu/command_buffer/common/gles2_cmd_format.h" | 9 #include "gpu/command_buffer/common/gles2_cmd_format.h" |
10 #include "gpu/command_buffer/common/gles2_cmd_utils.h" | 10 #include "gpu/command_buffer/common/gles2_cmd_utils.h" |
(...skipping 25 matching lines...) Expand all Loading... |
36 using ::testing::_; | 36 using ::testing::_; |
37 using ::testing::DoAll; | 37 using ::testing::DoAll; |
38 using ::testing::InSequence; | 38 using ::testing::InSequence; |
39 using ::testing::Invoke; | 39 using ::testing::Invoke; |
40 using ::testing::MatcherCast; | 40 using ::testing::MatcherCast; |
41 using ::testing::Mock; | 41 using ::testing::Mock; |
42 using ::testing::Pointee; | 42 using ::testing::Pointee; |
43 using ::testing::Return; | 43 using ::testing::Return; |
44 using ::testing::SaveArg; | 44 using ::testing::SaveArg; |
45 using ::testing::SetArrayArgument; | 45 using ::testing::SetArrayArgument; |
46 using ::testing::SetArgumentPointee; | |
47 using ::testing::SetArgPointee; | 46 using ::testing::SetArgPointee; |
48 using ::testing::StrEq; | 47 using ::testing::StrEq; |
49 using ::testing::StrictMock; | 48 using ::testing::StrictMock; |
50 | 49 |
51 namespace gpu { | 50 namespace gpu { |
52 namespace gles2 { | 51 namespace gles2 { |
53 | 52 |
54 using namespace cmds; | 53 using namespace cmds; |
55 | 54 |
56 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) { | 55 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) { |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
115 EXPECT_EQ(GL_NO_ERROR, GetGLError()); | 114 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
116 bucket = decoder_->GetBucket(kBucketId); | 115 bucket = decoder_->GetBucket(kBucketId); |
117 ASSERT_TRUE(bucket != NULL); | 116 ASSERT_TRUE(bucket != NULL); |
118 EXPECT_EQ(sizeof(UniformBlocksHeader), bucket->size()); | 117 EXPECT_EQ(sizeof(UniformBlocksHeader), bucket->size()); |
119 UniformBlocksHeader* header = | 118 UniformBlocksHeader* header = |
120 bucket->GetDataAs<UniformBlocksHeader*>(0, sizeof(UniformBlocksHeader)); | 119 bucket->GetDataAs<UniformBlocksHeader*>(0, sizeof(UniformBlocksHeader)); |
121 ASSERT_TRUE(header != NULL); | 120 ASSERT_TRUE(header != NULL); |
122 EXPECT_EQ(0u, header->num_uniform_blocks); | 121 EXPECT_EQ(0u, header->num_uniform_blocks); |
123 } | 122 } |
124 | 123 |
| 124 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMValidArgs) { |
| 125 const uint32 kBucketId = 123; |
| 126 GetUniformsES3CHROMIUM cmd; |
| 127 cmd.Init(client_program_id_, kBucketId); |
| 128 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 129 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 130 .RetiresOnSaturation(); |
| 131 EXPECT_CALL(*gl_, |
| 132 GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _)) |
| 133 .WillOnce(SetArgPointee<2>(0)) |
| 134 .RetiresOnSaturation(); |
| 135 decoder_->set_unsafe_es3_apis_enabled(true); |
| 136 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 137 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 138 EXPECT_EQ(sizeof(UniformsES3Header), bucket->size()); |
| 139 UniformsES3Header* header = |
| 140 bucket->GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header)); |
| 141 EXPECT_TRUE(header != NULL); |
| 142 EXPECT_EQ(0u, header->num_uniforms); |
| 143 decoder_->set_unsafe_es3_apis_enabled(false); |
| 144 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd)); |
| 145 } |
| 146 |
| 147 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMInvalidArgs) { |
| 148 const uint32 kBucketId = 123; |
| 149 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 150 EXPECT_TRUE(bucket == NULL); |
| 151 GetUniformsES3CHROMIUM cmd; |
| 152 cmd.Init(kInvalidClientId, kBucketId); |
| 153 decoder_->set_unsafe_es3_apis_enabled(true); |
| 154 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 155 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 156 bucket = decoder_->GetBucket(kBucketId); |
| 157 ASSERT_TRUE(bucket != NULL); |
| 158 EXPECT_EQ(sizeof(UniformsES3Header), bucket->size()); |
| 159 UniformsES3Header* header = |
| 160 bucket->GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header)); |
| 161 ASSERT_TRUE(header != NULL); |
| 162 EXPECT_EQ(0u, header->num_uniforms); |
| 163 } |
| 164 |
| 165 TEST_P(GLES2DecoderWithShaderTest, |
| 166 GetTransformFeedbackVaryingsCHROMIUMValidArgs) { |
| 167 const uint32 kBucketId = 123; |
| 168 GetTransformFeedbackVaryingsCHROMIUM cmd; |
| 169 cmd.Init(client_program_id_, kBucketId); |
| 170 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 171 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 172 .RetiresOnSaturation(); |
| 173 EXPECT_CALL(*gl_, |
| 174 GetProgramiv( |
| 175 kServiceProgramId, GL_TRANSFORM_FEEDBACK_VARYINGS, _)) |
| 176 .WillOnce(SetArgPointee<2>(0)) |
| 177 .RetiresOnSaturation(); |
| 178 decoder_->set_unsafe_es3_apis_enabled(true); |
| 179 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 180 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 181 EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket->size()); |
| 182 TransformFeedbackVaryingsHeader* header = |
| 183 bucket->GetDataAs<TransformFeedbackVaryingsHeader*>( |
| 184 0, sizeof(TransformFeedbackVaryingsHeader)); |
| 185 EXPECT_TRUE(header != NULL); |
| 186 EXPECT_EQ(0u, header->num_transform_feedback_varyings); |
| 187 decoder_->set_unsafe_es3_apis_enabled(false); |
| 188 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd)); |
| 189 } |
| 190 |
| 191 TEST_P(GLES2DecoderWithShaderTest, |
| 192 GetTransformFeedbackVaryingsCHROMIUMInvalidArgs) { |
| 193 const uint32 kBucketId = 123; |
| 194 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 195 EXPECT_TRUE(bucket == NULL); |
| 196 GetTransformFeedbackVaryingsCHROMIUM cmd; |
| 197 cmd.Init(kInvalidClientId, kBucketId); |
| 198 decoder_->set_unsafe_es3_apis_enabled(true); |
| 199 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 200 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 201 bucket = decoder_->GetBucket(kBucketId); |
| 202 ASSERT_TRUE(bucket != NULL); |
| 203 EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket->size()); |
| 204 TransformFeedbackVaryingsHeader* header = |
| 205 bucket->GetDataAs<TransformFeedbackVaryingsHeader*>( |
| 206 0, sizeof(TransformFeedbackVaryingsHeader)); |
| 207 ASSERT_TRUE(header != NULL); |
| 208 EXPECT_EQ(0u, header->num_transform_feedback_varyings); |
| 209 } |
| 210 |
125 TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) { | 211 TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) { |
126 GetUniformiv::Result* result = | 212 GetUniformiv::Result* result = |
127 static_cast<GetUniformiv::Result*>(shared_memory_address_); | 213 static_cast<GetUniformiv::Result*>(shared_memory_address_); |
128 result->size = 0; | 214 result->size = 0; |
129 GetUniformiv cmd; | 215 GetUniformiv cmd; |
130 cmd.Init(client_program_id_, | 216 cmd.Init(client_program_id_, |
131 kUniform2FakeLocation, | 217 kUniform2FakeLocation, |
132 kSharedMemoryId, | 218 kSharedMemoryId, |
133 kSharedMemoryOffset); | 219 kSharedMemoryOffset); |
134 EXPECT_CALL(*gl_, GetUniformiv(kServiceProgramId, kUniform2RealLocation, _)) | 220 EXPECT_CALL(*gl_, GetUniformiv(kServiceProgramId, kUniform2RealLocation, _)) |
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
337 kInvalidSharedMemoryOffset); | 423 kInvalidSharedMemoryOffset); |
338 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); | 424 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
339 }; | 425 }; |
340 | 426 |
341 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) { | 427 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) { |
342 GetAttachedShaders cmd; | 428 GetAttachedShaders cmd; |
343 typedef GetAttachedShaders::Result Result; | 429 typedef GetAttachedShaders::Result Result; |
344 Result* result = static_cast<Result*>(shared_memory_address_); | 430 Result* result = static_cast<Result*>(shared_memory_address_); |
345 result->size = 0; | 431 result->size = 0; |
346 EXPECT_CALL(*gl_, GetAttachedShaders(kServiceProgramId, 1, _, _)).WillOnce( | 432 EXPECT_CALL(*gl_, GetAttachedShaders(kServiceProgramId, 1, _, _)).WillOnce( |
347 DoAll(SetArgumentPointee<2>(1), SetArgumentPointee<3>(kServiceShaderId))); | 433 DoAll(SetArgPointee<2>(1), SetArgPointee<3>(kServiceShaderId))); |
348 cmd.Init(client_program_id_, | 434 cmd.Init(client_program_id_, |
349 shared_memory_id_, | 435 shared_memory_id_, |
350 shared_memory_offset_, | 436 shared_memory_offset_, |
351 Result::ComputeSize(1)); | 437 Result::ComputeSize(1)); |
352 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); | 438 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
353 EXPECT_EQ(1, result->GetNumResults()); | 439 EXPECT_EQ(1, result->GetNumResults()); |
354 EXPECT_EQ(client_shader_id_, result->GetData()[0]); | 440 EXPECT_EQ(client_shader_id_, result->GetData()[0]); |
355 EXPECT_EQ(GL_NO_ERROR, GetGLError()); | 441 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
356 } | 442 } |
357 | 443 |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
402 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) { | 488 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) { |
403 ScopedGLImplementationSetter gl_impl(::gfx::kGLImplementationEGLGLES2); | 489 ScopedGLImplementationSetter gl_impl(::gfx::kGLImplementationEGLGLES2); |
404 GetShaderPrecisionFormat cmd; | 490 GetShaderPrecisionFormat cmd; |
405 typedef GetShaderPrecisionFormat::Result Result; | 491 typedef GetShaderPrecisionFormat::Result Result; |
406 Result* result = static_cast<Result*>(shared_memory_address_); | 492 Result* result = static_cast<Result*>(shared_memory_address_); |
407 result->success = 0; | 493 result->success = 0; |
408 const GLint range[2] = {62, 62}; | 494 const GLint range[2] = {62, 62}; |
409 const GLint precision = 16; | 495 const GLint precision = 16; |
410 EXPECT_CALL(*gl_, GetShaderPrecisionFormat(_, _, _, _)) | 496 EXPECT_CALL(*gl_, GetShaderPrecisionFormat(_, _, _, _)) |
411 .WillOnce(DoAll(SetArrayArgument<2>(range, range + 2), | 497 .WillOnce(DoAll(SetArrayArgument<2>(range, range + 2), |
412 SetArgumentPointee<3>(precision))) | 498 SetArgPointee<3>(precision))) |
413 .RetiresOnSaturation(); | 499 .RetiresOnSaturation(); |
414 cmd.Init(GL_VERTEX_SHADER, | 500 cmd.Init(GL_VERTEX_SHADER, |
415 GL_HIGH_FLOAT, | 501 GL_HIGH_FLOAT, |
416 shared_memory_id_, | 502 shared_memory_id_, |
417 shared_memory_offset_); | 503 shared_memory_offset_); |
418 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); | 504 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
419 EXPECT_NE(0, result->success); | 505 EXPECT_NE(0, result->success); |
420 EXPECT_EQ(range[0], result->min_range); | 506 EXPECT_EQ(range[0], result->min_range); |
421 EXPECT_EQ(range[1], result->max_range); | 507 EXPECT_EQ(range[1], result->max_range); |
422 EXPECT_EQ(precision, result->precision); | 508 EXPECT_EQ(precision, result->precision); |
(...skipping 251 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
674 shared_memory_offset_); | 760 shared_memory_offset_); |
675 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); | 761 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
676 cmd.Init(client_program_id_, | 762 cmd.Init(client_program_id_, |
677 0, | 763 0, |
678 kBucketId, | 764 kBucketId, |
679 shared_memory_id_, | 765 shared_memory_id_, |
680 kInvalidSharedMemoryOffset); | 766 kInvalidSharedMemoryOffset); |
681 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); | 767 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
682 } | 768 } |
683 | 769 |
| 770 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivSucceeds) { |
| 771 GetActiveUniformBlockiv cmd; |
| 772 typedef GetActiveUniformBlockiv::Result Result; |
| 773 Result* result = static_cast<Result*>(shared_memory_address_); |
| 774 GLenum kPname[] { |
| 775 GL_UNIFORM_BLOCK_BINDING, |
| 776 GL_UNIFORM_BLOCK_DATA_SIZE, |
| 777 GL_UNIFORM_BLOCK_NAME_LENGTH, |
| 778 GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, |
| 779 GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, |
| 780 GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, |
| 781 GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, |
| 782 }; |
| 783 for (size_t ii = 0; ii < arraysize(kPname); ++ii) { |
| 784 result->SetNumResults(0); |
| 785 cmd.Init(client_program_id_, |
| 786 0, |
| 787 kPname[ii], |
| 788 shared_memory_id_, |
| 789 shared_memory_offset_); |
| 790 EXPECT_CALL(*gl_, GetError()) |
| 791 .WillOnce(Return(GL_NO_ERROR)) |
| 792 .WillOnce(Return(GL_NO_ERROR)) |
| 793 .RetiresOnSaturation(); |
| 794 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 795 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 796 .RetiresOnSaturation(); |
| 797 if (kPname[ii] == GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) { |
| 798 EXPECT_CALL(*gl_, GetError()) |
| 799 .WillOnce(Return(GL_NO_ERROR)) |
| 800 .RetiresOnSaturation(); |
| 801 EXPECT_CALL(*gl_, |
| 802 GetActiveUniformBlockiv(kServiceProgramId, 0, |
| 803 GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, _)) |
| 804 .WillOnce(SetArgPointee<3>(1)) |
| 805 .RetiresOnSaturation(); |
| 806 } |
| 807 EXPECT_CALL(*gl_, |
| 808 GetActiveUniformBlockiv( |
| 809 kServiceProgramId, 0, kPname[ii], _)) |
| 810 .WillOnce(SetArgPointee<3>(1976)) |
| 811 .RetiresOnSaturation(); |
| 812 decoder_->set_unsafe_es3_apis_enabled(true); |
| 813 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 814 EXPECT_EQ(1, result->GetNumResults()); |
| 815 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 816 EXPECT_EQ(1976, result->GetData()[0]); |
| 817 decoder_->set_unsafe_es3_apis_enabled(false); |
| 818 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd)); |
| 819 } |
| 820 } |
| 821 |
| 822 TEST_P(GLES2DecoderWithShaderTest, |
| 823 GetActiveUniformBlockivSucceedsZeroUniforms) { |
| 824 GetActiveUniformBlockiv cmd; |
| 825 typedef GetActiveUniformBlockiv::Result Result; |
| 826 Result* result = static_cast<Result*>(shared_memory_address_); |
| 827 result->SetNumResults(0); |
| 828 cmd.Init(client_program_id_, |
| 829 0, |
| 830 GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, |
| 831 shared_memory_id_, |
| 832 shared_memory_offset_); |
| 833 EXPECT_CALL(*gl_, GetError()) |
| 834 .WillOnce(Return(GL_NO_ERROR)) |
| 835 .WillOnce(Return(GL_NO_ERROR)) |
| 836 .WillOnce(Return(GL_NO_ERROR)) |
| 837 .RetiresOnSaturation(); |
| 838 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 839 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 840 .RetiresOnSaturation(); |
| 841 EXPECT_CALL(*gl_, |
| 842 GetActiveUniformBlockiv( |
| 843 kServiceProgramId, 0, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, _)) |
| 844 .WillOnce(SetArgPointee<3>(0)) |
| 845 .RetiresOnSaturation(); |
| 846 EXPECT_CALL(*gl_, |
| 847 GetActiveUniformBlockiv(kServiceProgramId, 0, |
| 848 GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, _)) |
| 849 .Times(1) |
| 850 .RetiresOnSaturation(); |
| 851 decoder_->set_unsafe_es3_apis_enabled(true); |
| 852 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 853 EXPECT_EQ(0, result->GetNumResults()); |
| 854 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 855 } |
| 856 |
| 857 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivUnlinkedProgram) { |
| 858 GetActiveUniformBlockiv cmd; |
| 859 typedef GetActiveUniformBlockiv::Result Result; |
| 860 Result* result = static_cast<Result*>(shared_memory_address_); |
| 861 result->SetNumResults(0); |
| 862 cmd.Init(client_program_id_, |
| 863 0, |
| 864 GL_UNIFORM_BLOCK_BINDING, |
| 865 shared_memory_id_, |
| 866 shared_memory_offset_); |
| 867 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 868 .WillOnce(SetArgPointee<2>(GL_FALSE)) |
| 869 .RetiresOnSaturation(); |
| 870 decoder_->set_unsafe_es3_apis_enabled(true); |
| 871 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 872 EXPECT_EQ(0, result->GetNumResults()); |
| 873 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 874 } |
| 875 |
| 876 TEST_P(GLES2DecoderWithShaderTest, |
| 877 GetActiveUniformBlockivResultNotInitFails) { |
| 878 GetActiveUniformBlockiv cmd; |
| 879 typedef GetActiveUniformBlockiv::Result Result; |
| 880 Result* result = static_cast<Result*>(shared_memory_address_); |
| 881 result->SetNumResults(1); // Should be initialized to 0. |
| 882 cmd.Init(client_program_id_, |
| 883 0, |
| 884 GL_UNIFORM_BLOCK_BINDING, |
| 885 shared_memory_id_, |
| 886 shared_memory_offset_); |
| 887 decoder_->set_unsafe_es3_apis_enabled(true); |
| 888 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 889 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 890 .RetiresOnSaturation(); |
| 891 EXPECT_CALL(*gl_, GetError()) |
| 892 .WillOnce(Return(GL_NO_ERROR)) |
| 893 .RetiresOnSaturation(); |
| 894 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 895 } |
| 896 |
| 897 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivBadProgramFails) { |
| 898 GetActiveUniformBlockiv cmd; |
| 899 typedef GetActiveUniformBlockiv::Result Result; |
| 900 Result* result = static_cast<Result*>(shared_memory_address_); |
| 901 result->SetNumResults(0); |
| 902 cmd.Init(kInvalidClientId, |
| 903 0, |
| 904 GL_UNIFORM_BLOCK_BINDING, |
| 905 shared_memory_id_, |
| 906 shared_memory_offset_); |
| 907 decoder_->set_unsafe_es3_apis_enabled(true); |
| 908 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 909 EXPECT_EQ(0, result->GetNumResults()); |
| 910 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 911 } |
| 912 |
| 913 TEST_P(GLES2DecoderWithShaderTest, |
| 914 GetActiveUniformBlockivBadSharedMemoryFails) { |
| 915 GetActiveUniformBlockiv cmd; |
| 916 decoder_->set_unsafe_es3_apis_enabled(true); |
| 917 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 918 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 919 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 920 .RetiresOnSaturation(); |
| 921 EXPECT_CALL(*gl_, GetError()) |
| 922 .WillOnce(Return(GL_NO_ERROR)) |
| 923 .WillOnce(Return(GL_NO_ERROR)) |
| 924 .RetiresOnSaturation(); |
| 925 cmd.Init(client_program_id_, |
| 926 0, |
| 927 GL_UNIFORM_BLOCK_BINDING, |
| 928 kInvalidSharedMemoryId, |
| 929 shared_memory_offset_); |
| 930 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 931 cmd.Init(client_program_id_, |
| 932 0, |
| 933 GL_UNIFORM_BLOCK_BINDING, |
| 934 shared_memory_id_, |
| 935 kInvalidSharedMemoryOffset); |
| 936 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 937 } |
| 938 |
684 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) { | 939 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) { |
685 const GLuint kAttribIndex = 1; | 940 const GLuint kAttribIndex = 1; |
686 const uint32 kBucketId = 123; | 941 const uint32 kBucketId = 123; |
687 GetActiveAttrib cmd; | 942 GetActiveAttrib cmd; |
688 typedef GetActiveAttrib::Result Result; | 943 typedef GetActiveAttrib::Result Result; |
689 Result* result = static_cast<Result*>(shared_memory_address_); | 944 Result* result = static_cast<Result*>(shared_memory_address_); |
690 result->success = 0; | 945 result->success = 0; |
691 cmd.Init(client_program_id_, | 946 cmd.Init(client_program_id_, |
692 kAttribIndex, | 947 kAttribIndex, |
693 kBucketId, | 948 kBucketId, |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
775 shared_memory_offset_); | 1030 shared_memory_offset_); |
776 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); | 1031 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
777 cmd.Init(client_program_id_, | 1032 cmd.Init(client_program_id_, |
778 kAttribIndex, | 1033 kAttribIndex, |
779 kBucketId, | 1034 kBucketId, |
780 shared_memory_id_, | 1035 shared_memory_id_, |
781 kInvalidSharedMemoryOffset); | 1036 kInvalidSharedMemoryOffset); |
782 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); | 1037 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
783 } | 1038 } |
784 | 1039 |
| 1040 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesSucceeds) { |
| 1041 const uint32 kBucketId = 123; |
| 1042 const char kName0[] = "Cow"; |
| 1043 const char kName1[] = "Chicken"; |
| 1044 const char* kNames[] = { kName0, kName1 }; |
| 1045 const size_t kCount = arraysize(kNames); |
| 1046 const char kValidStrEnd = 0; |
| 1047 const GLuint kIndices[] = { 1, 2 }; |
| 1048 SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd); |
| 1049 GetUniformIndices::Result* result = |
| 1050 static_cast<GetUniformIndices::Result*>(shared_memory_address_); |
| 1051 GetUniformIndices cmd; |
| 1052 cmd.Init(client_program_id_, |
| 1053 kBucketId, |
| 1054 kSharedMemoryId, |
| 1055 kSharedMemoryOffset); |
| 1056 EXPECT_CALL(*gl_, GetUniformIndices(kServiceProgramId, kCount, _, _)) |
| 1057 .WillOnce(SetArrayArgument<3>(kIndices, kIndices + kCount)) |
| 1058 .RetiresOnSaturation(); |
| 1059 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1060 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 1061 .RetiresOnSaturation(); |
| 1062 EXPECT_CALL(*gl_, GetError()) |
| 1063 .WillOnce(Return(GL_NO_ERROR)) |
| 1064 .WillOnce(Return(GL_NO_ERROR)) |
| 1065 .RetiresOnSaturation(); |
| 1066 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1067 result->size = 0; |
| 1068 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1069 EXPECT_EQ(kCount, static_cast<size_t>(result->GetNumResults())); |
| 1070 for (size_t ii = 0; ii < kCount; ++ii) { |
| 1071 EXPECT_EQ(kIndices[ii], result->GetData()[ii]); |
| 1072 } |
| 1073 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 1074 decoder_->set_unsafe_es3_apis_enabled(false); |
| 1075 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd)); |
| 1076 } |
| 1077 |
| 1078 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadProgramFails) { |
| 1079 const uint32 kBucketId = 123; |
| 1080 const char kName0[] = "Cow"; |
| 1081 const char kName1[] = "Chicken"; |
| 1082 const char* kNames[] = { kName0, kName1 }; |
| 1083 const size_t kCount = arraysize(kNames); |
| 1084 const char kValidStrEnd = 0; |
| 1085 SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd); |
| 1086 GetUniformIndices::Result* result = |
| 1087 static_cast<GetUniformIndices::Result*>(shared_memory_address_); |
| 1088 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1089 GetUniformIndices cmd; |
| 1090 // None-existant program |
| 1091 cmd.Init(kInvalidClientId, |
| 1092 kBucketId, |
| 1093 kSharedMemoryId, |
| 1094 kSharedMemoryOffset); |
| 1095 result->size = 0; |
| 1096 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1097 EXPECT_EQ(0, result->GetNumResults()); |
| 1098 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1099 // Unlinked program. |
| 1100 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1101 .WillOnce(SetArgPointee<2>(GL_FALSE)) |
| 1102 .RetiresOnSaturation(); |
| 1103 cmd.Init(client_program_id_, |
| 1104 kBucketId, |
| 1105 kSharedMemoryId, |
| 1106 kSharedMemoryOffset); |
| 1107 result->size = 0; |
| 1108 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1109 EXPECT_EQ(0, result->GetNumResults()); |
| 1110 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 1111 } |
| 1112 |
| 1113 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadParamsFails) { |
| 1114 const uint32 kBucketId = 123; |
| 1115 const char kName0[] = "Cow"; |
| 1116 const char kName1[] = "Chicken"; |
| 1117 const char* kNames[] = { kName0, kName1 }; |
| 1118 const size_t kCount = arraysize(kNames); |
| 1119 const char kValidStrEnd = 0; |
| 1120 const GLuint kIndices[] = { 1, 2 }; |
| 1121 SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd); |
| 1122 GetUniformIndices::Result* result = |
| 1123 static_cast<GetUniformIndices::Result*>(shared_memory_address_); |
| 1124 GetUniformIndices cmd; |
| 1125 cmd.Init(client_program_id_, |
| 1126 kBucketId, |
| 1127 kSharedMemoryId, |
| 1128 kSharedMemoryOffset); |
| 1129 EXPECT_CALL(*gl_, GetUniformIndices(kServiceProgramId, kCount, _, _)) |
| 1130 .WillOnce(SetArrayArgument<3>(kIndices, kIndices + kCount)) |
| 1131 .RetiresOnSaturation(); |
| 1132 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1133 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 1134 .RetiresOnSaturation(); |
| 1135 EXPECT_CALL(*gl_, GetError()) |
| 1136 .WillOnce(Return(GL_NO_ERROR)) |
| 1137 .WillOnce(Return(GL_INVALID_VALUE)) |
| 1138 .RetiresOnSaturation(); |
| 1139 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1140 result->size = 0; |
| 1141 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1142 EXPECT_EQ(0, result->GetNumResults()); |
| 1143 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1144 } |
| 1145 |
| 1146 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesResultNotInitFails) { |
| 1147 const uint32 kBucketId = 123; |
| 1148 const char kName0[] = "Cow"; |
| 1149 const char kName1[] = "Chicken"; |
| 1150 const char* kNames[] = { kName0, kName1 }; |
| 1151 const size_t kCount = arraysize(kNames); |
| 1152 const char kValidStrEnd = 0; |
| 1153 SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd); |
| 1154 GetUniformIndices::Result* result = |
| 1155 static_cast<GetUniformIndices::Result*>(shared_memory_address_); |
| 1156 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1157 GetUniformIndices cmd; |
| 1158 result->size = 1976; // Any value other than 0. |
| 1159 cmd.Init(kInvalidClientId, |
| 1160 kBucketId, |
| 1161 kSharedMemoryId, |
| 1162 kSharedMemoryOffset); |
| 1163 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1164 } |
| 1165 |
| 1166 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadSharedMemoryFails) { |
| 1167 const uint32 kBucketId = 123; |
| 1168 const char kName0[] = "Cow"; |
| 1169 const char kName1[] = "Chicken"; |
| 1170 const char* kNames[] = { kName0, kName1 }; |
| 1171 const size_t kCount = arraysize(kNames); |
| 1172 const char kValidStrEnd = 0; |
| 1173 SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd); |
| 1174 GetUniformIndices::Result* result = |
| 1175 static_cast<GetUniformIndices::Result*>(shared_memory_address_); |
| 1176 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1177 GetUniformIndices cmd; |
| 1178 cmd.Init(client_program_id_, |
| 1179 kBucketId, |
| 1180 kInvalidSharedMemoryId, |
| 1181 kSharedMemoryOffset); |
| 1182 result->size = 0; |
| 1183 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1184 cmd.Init(client_program_id_, |
| 1185 kBucketId, |
| 1186 kSharedMemoryId, |
| 1187 kInvalidSharedMemoryOffset); |
| 1188 result->size = 0; |
| 1189 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1190 } |
| 1191 |
| 1192 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivSucceeds) { |
| 1193 const uint32 kBucketId = 123; |
| 1194 const GLuint kIndices[] = { 1, 2 }; |
| 1195 const GLint kResults[] = { 1976, 321 }; |
| 1196 const size_t kCount = arraysize(kIndices); |
| 1197 SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount); |
| 1198 GetActiveUniformsiv::Result* result = |
| 1199 static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_); |
| 1200 GetActiveUniformsiv cmd; |
| 1201 cmd.Init(client_program_id_, |
| 1202 kBucketId, |
| 1203 GL_UNIFORM_TYPE, |
| 1204 kSharedMemoryId, |
| 1205 kSharedMemoryOffset); |
| 1206 EXPECT_CALL(*gl_, |
| 1207 GetActiveUniformsiv( |
| 1208 kServiceProgramId, kCount, _, GL_UNIFORM_TYPE, _)) |
| 1209 .WillOnce(SetArrayArgument<4>(kResults, kResults + kCount)) |
| 1210 .RetiresOnSaturation(); |
| 1211 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1212 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 1213 .RetiresOnSaturation(); |
| 1214 EXPECT_CALL(*gl_, GetError()) |
| 1215 .WillOnce(Return(GL_NO_ERROR)) |
| 1216 .WillOnce(Return(GL_NO_ERROR)) |
| 1217 .RetiresOnSaturation(); |
| 1218 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1219 result->size = 0; |
| 1220 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1221 EXPECT_EQ(kCount, static_cast<size_t>(result->GetNumResults())); |
| 1222 for (size_t ii = 0; ii < kCount; ++ii) { |
| 1223 EXPECT_EQ(kResults[ii], result->GetData()[ii]); |
| 1224 } |
| 1225 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 1226 decoder_->set_unsafe_es3_apis_enabled(false); |
| 1227 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd)); |
| 1228 } |
| 1229 |
| 1230 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadProgramFails) { |
| 1231 const uint32 kBucketId = 123; |
| 1232 const GLuint kIndices[] = { 1, 2 }; |
| 1233 const size_t kCount = arraysize(kIndices); |
| 1234 SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount); |
| 1235 GetActiveUniformsiv::Result* result = |
| 1236 static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_); |
| 1237 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1238 GetActiveUniformsiv cmd; |
| 1239 // None-existant program |
| 1240 cmd.Init(kInvalidClientId, |
| 1241 kBucketId, |
| 1242 GL_UNIFORM_TYPE, |
| 1243 kSharedMemoryId, |
| 1244 kSharedMemoryOffset); |
| 1245 result->size = 0; |
| 1246 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1247 EXPECT_EQ(0, result->GetNumResults()); |
| 1248 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1249 // Unlinked program. |
| 1250 cmd.Init(client_program_id_, |
| 1251 kBucketId, |
| 1252 GL_UNIFORM_TYPE, |
| 1253 kSharedMemoryId, |
| 1254 kSharedMemoryOffset); |
| 1255 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1256 .WillOnce(SetArgPointee<2>(GL_FALSE)) |
| 1257 .RetiresOnSaturation(); |
| 1258 result->size = 0; |
| 1259 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1260 EXPECT_EQ(0, result->GetNumResults()); |
| 1261 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError()); |
| 1262 } |
| 1263 |
| 1264 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadParamsFails) { |
| 1265 const uint32 kBucketId = 123; |
| 1266 const GLuint kIndices[] = { 1, 2 }; |
| 1267 const GLint kResults[] = { 1976, 321 }; |
| 1268 const size_t kCount = arraysize(kIndices); |
| 1269 SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount); |
| 1270 GetActiveUniformsiv::Result* result = |
| 1271 static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_); |
| 1272 GetActiveUniformsiv cmd; |
| 1273 cmd.Init(client_program_id_, |
| 1274 kBucketId, |
| 1275 GL_UNIFORM_TYPE, |
| 1276 kSharedMemoryId, |
| 1277 kSharedMemoryOffset); |
| 1278 EXPECT_CALL(*gl_, |
| 1279 GetActiveUniformsiv( |
| 1280 kServiceProgramId, kCount, _, GL_UNIFORM_TYPE, _)) |
| 1281 .WillOnce(SetArrayArgument<4>(kResults, kResults + kCount)) |
| 1282 .RetiresOnSaturation(); |
| 1283 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1284 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 1285 .RetiresOnSaturation(); |
| 1286 EXPECT_CALL(*gl_, GetError()) |
| 1287 .WillOnce(Return(GL_NO_ERROR)) |
| 1288 .WillOnce(Return(GL_INVALID_VALUE)) |
| 1289 .RetiresOnSaturation(); |
| 1290 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1291 result->size = 0; |
| 1292 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1293 EXPECT_EQ(0, result->GetNumResults()); |
| 1294 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1295 } |
| 1296 |
| 1297 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivResultNotInitFails) { |
| 1298 const uint32 kBucketId = 123; |
| 1299 const GLuint kIndices[] = { 1, 2 }; |
| 1300 const size_t kCount = arraysize(kIndices); |
| 1301 SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount); |
| 1302 GetActiveUniformsiv::Result* result = |
| 1303 static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_); |
| 1304 GetActiveUniformsiv cmd; |
| 1305 cmd.Init(client_program_id_, |
| 1306 kBucketId, |
| 1307 GL_UNIFORM_TYPE, |
| 1308 kSharedMemoryId, |
| 1309 kSharedMemoryOffset); |
| 1310 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1311 result->size = 1976; // Any value other than 0. |
| 1312 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1313 } |
| 1314 |
| 1315 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadSharedMemoryFails) { |
| 1316 const uint32 kBucketId = 123; |
| 1317 const GLuint kIndices[] = { 1, 2 }; |
| 1318 const size_t kCount = arraysize(kIndices); |
| 1319 SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount); |
| 1320 GetActiveUniformsiv::Result* result = |
| 1321 static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_); |
| 1322 GetActiveUniformsiv cmd; |
| 1323 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1324 result->size = 0; |
| 1325 cmd.Init(client_program_id_, |
| 1326 kBucketId, |
| 1327 GL_UNIFORM_TYPE, |
| 1328 kInvalidSharedMemoryId, |
| 1329 kSharedMemoryOffset); |
| 1330 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1331 result->size = 0; |
| 1332 cmd.Init(client_program_id_, |
| 1333 kBucketId, |
| 1334 GL_UNIFORM_TYPE, |
| 1335 kSharedMemoryId, |
| 1336 kInvalidSharedMemoryOffset); |
| 1337 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1338 } |
| 1339 |
785 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) { | 1340 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) { |
786 const char* kInfo = "hello"; | 1341 const char* kInfo = "hello"; |
787 const uint32 kBucketId = 123; | 1342 const uint32 kBucketId = 123; |
788 CompileShader compile_cmd; | 1343 CompileShader compile_cmd; |
789 GetShaderInfoLog cmd; | 1344 GetShaderInfoLog cmd; |
790 EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _)); | 1345 EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _)); |
791 EXPECT_CALL(*gl_, CompileShader(kServiceShaderId)); | 1346 EXPECT_CALL(*gl_, CompileShader(kServiceShaderId)); |
792 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _)) | 1347 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _)) |
793 .WillOnce(SetArgumentPointee<2>(GL_FALSE)) | 1348 .WillOnce(SetArgPointee<2>(GL_FALSE)) |
794 .RetiresOnSaturation(); | 1349 .RetiresOnSaturation(); |
795 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _)) | 1350 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _)) |
796 .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1)) | 1351 .WillOnce(SetArgPointee<2>(strlen(kInfo) + 1)) |
797 .RetiresOnSaturation(); | 1352 .RetiresOnSaturation(); |
798 EXPECT_CALL(*gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _)) | 1353 EXPECT_CALL(*gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _)) |
799 .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)), | 1354 .WillOnce(DoAll(SetArgPointee<2>(strlen(kInfo)), |
800 SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1))); | 1355 SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1))); |
801 compile_cmd.Init(client_shader_id_); | 1356 compile_cmd.Init(client_shader_id_); |
802 cmd.Init(client_shader_id_, kBucketId); | 1357 cmd.Init(client_shader_id_, kBucketId); |
803 EXPECT_EQ(error::kNoError, ExecuteCmd(compile_cmd)); | 1358 EXPECT_EQ(error::kNoError, ExecuteCmd(compile_cmd)); |
804 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); | 1359 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
805 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); | 1360 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
806 ASSERT_TRUE(bucket != NULL); | 1361 ASSERT_TRUE(bucket != NULL); |
807 EXPECT_EQ(strlen(kInfo) + 1, bucket->size()); | 1362 EXPECT_EQ(strlen(kInfo) + 1, bucket->size()); |
808 EXPECT_EQ(0, | 1363 EXPECT_EQ(0, |
809 memcmp(bucket->GetData(0, bucket->size()), kInfo, bucket->size())); | 1364 memcmp(bucket->GetData(0, bucket->size()), kInfo, bucket->size())); |
810 EXPECT_EQ(GL_NO_ERROR, GetGLError()); | 1365 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
811 } | 1366 } |
812 | 1367 |
813 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) { | 1368 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) { |
814 const uint32 kBucketId = 123; | 1369 const uint32 kBucketId = 123; |
815 GetShaderInfoLog cmd; | 1370 GetShaderInfoLog cmd; |
816 cmd.Init(kInvalidClientId, kBucketId); | 1371 cmd.Init(kInvalidClientId, kBucketId); |
817 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); | 1372 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
818 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); | 1373 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
819 } | 1374 } |
820 | 1375 |
| 1376 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingSucceeds) { |
| 1377 const GLuint kIndex = 1; |
| 1378 const uint32 kBucketId = 123; |
| 1379 const char kName[] = "HolyCow"; |
| 1380 const GLsizei kBufferSize = static_cast<GLsizei>(strlen(kName) + 1); |
| 1381 const GLsizei kSize = 2; |
| 1382 const GLenum kType = GL_FLOAT_VEC2; |
| 1383 GetTransformFeedbackVarying cmd; |
| 1384 typedef GetTransformFeedbackVarying::Result Result; |
| 1385 Result* result = static_cast<Result*>(shared_memory_address_); |
| 1386 result->success = 0; |
| 1387 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1388 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 1389 .RetiresOnSaturation(); |
| 1390 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, |
| 1391 GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, _)) |
| 1392 .WillOnce(SetArgPointee<2>(kBufferSize)) |
| 1393 .RetiresOnSaturation(); |
| 1394 EXPECT_CALL(*gl_, GetError()) |
| 1395 .WillOnce(Return(GL_NO_ERROR)) |
| 1396 .WillOnce(Return(GL_NO_ERROR)) |
| 1397 .RetiresOnSaturation(); |
| 1398 EXPECT_CALL(*gl_, |
| 1399 GetTransformFeedbackVarying( |
| 1400 kServiceProgramId, kIndex, _, _, _, _, _)) |
| 1401 .WillOnce(DoAll(SetArgPointee<3>(kBufferSize - 1), |
| 1402 SetArgPointee<4>(kSize), |
| 1403 SetArgPointee<5>(kType), |
| 1404 SetArrayArgument<6>(kName, kName + kBufferSize))) |
| 1405 .RetiresOnSaturation(); |
| 1406 cmd.Init(client_program_id_, |
| 1407 kIndex, |
| 1408 kBucketId, |
| 1409 shared_memory_id_, |
| 1410 shared_memory_offset_); |
| 1411 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1412 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1413 EXPECT_NE(0, result->success); |
| 1414 EXPECT_EQ(kSize, static_cast<GLsizei>(result->size)); |
| 1415 EXPECT_EQ(kType, static_cast<GLenum>(result->type)); |
| 1416 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 1417 CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId); |
| 1418 ASSERT_TRUE(bucket != NULL); |
| 1419 EXPECT_EQ( |
| 1420 0, memcmp(bucket->GetData(0, bucket->size()), kName, bucket->size())); |
| 1421 decoder_->set_unsafe_es3_apis_enabled(false); |
| 1422 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd)); |
| 1423 } |
| 1424 |
| 1425 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingNotInitFails) { |
| 1426 const GLuint kIndex = 1; |
| 1427 const uint32 kBucketId = 123; |
| 1428 GetTransformFeedbackVarying cmd; |
| 1429 typedef GetTransformFeedbackVarying::Result Result; |
| 1430 Result* result = static_cast<Result*>(shared_memory_address_); |
| 1431 result->success = 1; |
| 1432 cmd.Init(client_program_id_, |
| 1433 kIndex, |
| 1434 kBucketId, |
| 1435 shared_memory_id_, |
| 1436 shared_memory_offset_); |
| 1437 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1438 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1439 } |
| 1440 |
| 1441 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadProgramFails) { |
| 1442 const GLuint kIndex = 1; |
| 1443 const uint32 kBucketId = 123; |
| 1444 GetTransformFeedbackVarying cmd; |
| 1445 typedef GetTransformFeedbackVarying::Result Result; |
| 1446 Result* result = static_cast<Result*>(shared_memory_address_); |
| 1447 result->success = 0; |
| 1448 cmd.Init(kInvalidClientId, |
| 1449 kIndex, |
| 1450 kBucketId, |
| 1451 shared_memory_id_, |
| 1452 shared_memory_offset_); |
| 1453 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1454 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1455 EXPECT_EQ(0, result->success); |
| 1456 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1457 } |
| 1458 |
| 1459 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadParamsFails) { |
| 1460 const GLuint kIndex = 1; |
| 1461 const uint32 kBucketId = 123; |
| 1462 const GLsizei kBufferSize = 10; |
| 1463 GetTransformFeedbackVarying cmd; |
| 1464 typedef GetTransformFeedbackVarying::Result Result; |
| 1465 Result* result = static_cast<Result*>(shared_memory_address_); |
| 1466 result->success = 0; |
| 1467 cmd.Init(client_program_id_, |
| 1468 kIndex, |
| 1469 kBucketId, |
| 1470 shared_memory_id_, |
| 1471 shared_memory_offset_); |
| 1472 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _)) |
| 1473 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
| 1474 .RetiresOnSaturation(); |
| 1475 EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, |
| 1476 GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, _)) |
| 1477 .WillOnce(SetArgPointee<2>(kBufferSize)) |
| 1478 .RetiresOnSaturation(); |
| 1479 EXPECT_CALL(*gl_, GetError()) |
| 1480 .WillOnce(Return(GL_NO_ERROR)) |
| 1481 .WillOnce(Return(GL_INVALID_VALUE)) |
| 1482 .RetiresOnSaturation(); |
| 1483 EXPECT_CALL(*gl_, |
| 1484 GetTransformFeedbackVarying( |
| 1485 kServiceProgramId, kIndex, _, _, _, _, _)) |
| 1486 .Times(1) |
| 1487 .RetiresOnSaturation(); |
| 1488 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1489 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1490 EXPECT_EQ(0, result->success); |
| 1491 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
| 1492 } |
| 1493 |
| 1494 TEST_P(GLES2DecoderWithShaderTest, |
| 1495 GetTransformFeedbackVaryingBadSharedMemoryFails) { |
| 1496 const GLuint kIndex = 1; |
| 1497 const uint32 kBucketId = 123; |
| 1498 GetTransformFeedbackVarying cmd; |
| 1499 typedef GetTransformFeedbackVarying::Result Result; |
| 1500 Result* result = static_cast<Result*>(shared_memory_address_); |
| 1501 result->success = 0; |
| 1502 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1503 cmd.Init(client_program_id_, |
| 1504 kIndex, |
| 1505 kBucketId, |
| 1506 kInvalidSharedMemoryId, |
| 1507 shared_memory_offset_); |
| 1508 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1509 cmd.Init(client_program_id_, |
| 1510 kIndex, |
| 1511 kBucketId, |
| 1512 shared_memory_id_, |
| 1513 kInvalidSharedMemoryOffset); |
| 1514 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
| 1515 } |
| 1516 |
821 TEST_P(GLES2DecoderTest, CompileShaderValidArgs) { | 1517 TEST_P(GLES2DecoderTest, CompileShaderValidArgs) { |
| 1518 // Compile shader should not actually call any GL calls yet. |
| 1519 CompileShader cmd; |
| 1520 cmd.Init(client_shader_id_); |
| 1521 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1522 |
| 1523 // Getting the shader compilation state should trigger the actual GL calls. |
822 EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _)); | 1524 EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _)); |
823 EXPECT_CALL(*gl_, CompileShader(kServiceShaderId)); | 1525 EXPECT_CALL(*gl_, CompileShader(kServiceShaderId)); |
824 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _)) | 1526 EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _)) |
825 .WillOnce(SetArgumentPointee<2>(GL_TRUE)) | 1527 .WillOnce(SetArgPointee<2>(GL_TRUE)) |
826 .RetiresOnSaturation(); | 1528 .RetiresOnSaturation(); |
827 CompileShader cmd; | 1529 EXPECT_CALL(*gl_, GetError()) |
828 cmd.Init(client_shader_id_); | 1530 .WillOnce(Return(GL_NO_ERROR)) |
829 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); | 1531 .WillOnce(Return(GL_NO_ERROR)) |
| 1532 .RetiresOnSaturation(); |
| 1533 |
| 1534 GetShaderiv status_cmd; |
| 1535 status_cmd.Init(client_shader_id_, GL_COMPILE_STATUS, |
| 1536 kSharedMemoryId, kSharedMemoryOffset); |
| 1537 EXPECT_EQ(error::kNoError, ExecuteCmd(status_cmd)); |
830 } | 1538 } |
831 | 1539 |
832 TEST_P(GLES2DecoderTest, CompileShaderInvalidArgs) { | 1540 TEST_P(GLES2DecoderTest, CompileShaderInvalidArgs) { |
833 CompileShader cmd; | 1541 CompileShader cmd; |
834 cmd.Init(kInvalidClientId); | 1542 cmd.Init(kInvalidClientId); |
835 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); | 1543 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
836 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); | 1544 EXPECT_EQ(GL_INVALID_VALUE, GetGLError()); |
837 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS | 1545 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS |
838 cmd.Init(client_program_id_); | 1546 cmd.Init(client_program_id_); |
839 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); | 1547 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
(...skipping 331 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1171 kInvalidSharedMemoryId, | 1879 kInvalidSharedMemoryId, |
1172 kSharedMemoryOffset); | 1880 kSharedMemoryOffset); |
1173 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); | 1881 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
1174 cmd.Init(client_program_id_, | 1882 cmd.Init(client_program_id_, |
1175 kBucketId, | 1883 kBucketId, |
1176 kSharedMemoryId, | 1884 kSharedMemoryId, |
1177 kInvalidSharedMemoryOffset); | 1885 kInvalidSharedMemoryOffset); |
1178 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); | 1886 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); |
1179 } | 1887 } |
1180 | 1888 |
| 1889 TEST_P(GLES2DecoderWithShaderTest, UniformBlockBindingValidArgs) { |
| 1890 EXPECT_CALL(*gl_, UniformBlockBinding(kServiceProgramId, 2, 3)); |
| 1891 SpecializedSetup<cmds::UniformBlockBinding, 0>(true); |
| 1892 cmds::UniformBlockBinding cmd; |
| 1893 cmd.Init(client_program_id_, 2, 3); |
| 1894 decoder_->set_unsafe_es3_apis_enabled(true); |
| 1895 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); |
| 1896 EXPECT_EQ(GL_NO_ERROR, GetGLError()); |
| 1897 decoder_->set_unsafe_es3_apis_enabled(false); |
| 1898 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd)); |
| 1899 } |
| 1900 |
1181 TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUMBucket) { | 1901 TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUMBucket) { |
1182 const uint32 kBucketId = 123; | 1902 const uint32 kBucketId = 123; |
1183 const GLint kLocation = 2; | 1903 const GLint kLocation = 2; |
1184 const char* kName = "testing"; | 1904 const char* kName = "testing"; |
1185 const char* kBadName1 = "gl_testing"; | 1905 const char* kBadName1 = "gl_testing"; |
1186 const char* kBadName2 = "testing[1]"; | 1906 const char* kBadName2 = "testing[1]"; |
1187 | 1907 |
1188 SetBucketAsCString(kBucketId, kName); | 1908 SetBucketAsCString(kBucketId, kName); |
1189 BindUniformLocationCHROMIUMBucket cmd; | 1909 BindUniformLocationCHROMIUMBucket cmd; |
1190 cmd.Init(client_program_id_, | 1910 cmd.Init(client_program_id_, |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1284 } | 2004 } |
1285 | 2005 |
1286 // TODO(gman): DeleteProgram | 2006 // TODO(gman): DeleteProgram |
1287 | 2007 |
1288 // TODO(gman): UseProgram | 2008 // TODO(gman): UseProgram |
1289 | 2009 |
1290 // TODO(gman): DeleteShader | 2010 // TODO(gman): DeleteShader |
1291 | 2011 |
1292 } // namespace gles2 | 2012 } // namespace gles2 |
1293 } // namespace gpu | 2013 } // namespace gpu |
OLD | NEW |