Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(13)

Side by Side Diff: gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc

Issue 935333002: Update from https://crrev.com/316786 (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698