Upstream version 10.39.225.0
[platform/framework/web/crosswalk.git] / src / gpu / command_buffer / service / gles2_cmd_decoder_unittest_1.cc
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
6
7 #include "gpu/command_buffer/common/gles2_cmd_format.h"
8 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
9 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
10 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
11 #include "gpu/command_buffer/service/context_group.h"
12 #include "gpu/command_buffer/service/program_manager.h"
13 #include "gpu/command_buffer/service/test_helper.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15 #include "ui/gl/gl_mock.h"
16
17 using ::gfx::MockGLInterface;
18 using ::testing::_;
19 using ::testing::DoAll;
20 using ::testing::InSequence;
21 using ::testing::MatcherCast;
22 using ::testing::Pointee;
23 using ::testing::Return;
24 using ::testing::SetArrayArgument;
25 using ::testing::SetArgumentPointee;
26 using ::testing::StrEq;
27
28 namespace gpu {
29 namespace gles2 {
30
31 namespace {
32 void ShaderCacheCb(const std::string& key, const std::string& shader) {
33 }
34 }  // namespace
35
36 class GLES2DecoderTest1 : public GLES2DecoderTestBase {
37  public:
38   GLES2DecoderTest1() { }
39 };
40
41 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest1, ::testing::Bool());
42
43 template <>
44 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenerateMipmap, 0>(
45     bool valid) {
46   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
47   DoTexImage2D(
48       GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
49       kSharedMemoryId, kSharedMemoryOffset);
50   if (valid) {
51     EXPECT_CALL(*gl_, GetError())
52         .WillOnce(Return(GL_NO_ERROR))
53         .WillOnce(Return(GL_NO_ERROR))
54         .RetiresOnSaturation();
55   }
56 };
57
58 template <>
59 void GLES2DecoderTestBase::SpecializedSetup<cmds::CheckFramebufferStatus, 0>(
60     bool /* valid */) {
61   // Give it a valid framebuffer.
62   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
63                     kServiceRenderbufferId);
64   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
65                     kServiceFramebufferId);
66   DoRenderbufferStorage(
67       GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 1, 1, GL_NO_ERROR);
68   DoFramebufferRenderbuffer(
69       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
70       client_renderbuffer_id_, kServiceRenderbufferId, GL_NO_ERROR);
71 };
72
73 template <>
74 void GLES2DecoderTestBase::SpecializedSetup<cmds::Clear, 0>(bool valid) {
75   if (valid) {
76     SetupExpectationsForApplyingDefaultDirtyState();
77   }
78 };
79
80 template <>
81 void GLES2DecoderTestBase::SpecializedSetup<cmds::ColorMask, 0>(
82     bool /* valid */) {
83   // We bind a framebuffer color the colormask test since the framebuffer
84   // will be considered RGB.
85   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
86                     kServiceFramebufferId);
87 };
88
89 template <>
90 void GLES2DecoderTestBase::SpecializedSetup<cmds::CopyTexImage2D, 0>(
91     bool valid) {
92   if (valid) {
93     EXPECT_CALL(*gl_, GetError())
94         .WillOnce(Return(GL_NO_ERROR))
95         .WillOnce(Return(GL_NO_ERROR))
96         .RetiresOnSaturation();
97   }
98 };
99
100 template <>
101 void GLES2DecoderTestBase::SpecializedSetup<cmds::CopyTexSubImage2D, 0>(
102     bool valid) {
103   if (valid) {
104     DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
105     DoTexImage2D(
106         GL_TEXTURE_2D, 2, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
107         kSharedMemoryId, kSharedMemoryOffset);
108   }
109 };
110
111 template <>
112 void GLES2DecoderTestBase::SpecializedSetup<cmds::DetachShader, 0>(bool valid) {
113   if (valid) {
114     EXPECT_CALL(*gl_,
115                 AttachShader(kServiceProgramId, kServiceShaderId))
116         .Times(1)
117         .RetiresOnSaturation();
118     cmds::AttachShader attach_cmd;
119     attach_cmd.Init(client_program_id_, client_shader_id_);
120     EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
121   }
122 };
123
124 template <>
125 void GLES2DecoderTestBase::SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(
126     bool valid) {
127   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
128                     kServiceFramebufferId);
129   if (valid) {
130     EXPECT_CALL(*gl_, GetError())
131         .WillOnce(Return(GL_NO_ERROR))
132         .WillOnce(Return(GL_NO_ERROR))
133         .RetiresOnSaturation();
134   }
135 };
136
137 template <>
138 void GLES2DecoderTestBase::SpecializedSetup<cmds::FramebufferTexture2D, 0>(
139     bool valid) {
140   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
141                     kServiceFramebufferId);
142   if (valid) {
143     EXPECT_CALL(*gl_, GetError())
144         .WillOnce(Return(GL_NO_ERROR))
145         .WillOnce(Return(GL_NO_ERROR))
146         .RetiresOnSaturation();
147   }
148 };
149
150 template <>
151 void GLES2DecoderTestBase::SpecializedSetup<
152     cmds::GetBufferParameteriv, 0>(bool /* valid */) {
153   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
154 };
155
156 template <>
157 void GLES2DecoderTestBase::SpecializedSetup<
158     cmds::GetFramebufferAttachmentParameteriv, 0>(bool /* valid */) {
159   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
160                     kServiceFramebufferId);
161 };
162
163 template <>
164 void GLES2DecoderTestBase::SpecializedSetup<
165     cmds::GetRenderbufferParameteriv, 0>(
166         bool /* valid */) {
167   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
168                     kServiceRenderbufferId);
169 };
170
171 template <>
172 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramiv, 0>(
173     bool valid) {
174   if (valid) {
175     // GetProgramiv calls ClearGLError then GetError to make sure
176     // it actually got a value so it can report correctly to the client.
177     EXPECT_CALL(*gl_, GetError())
178         .WillOnce(Return(GL_NO_ERROR))
179         .RetiresOnSaturation();
180     EXPECT_CALL(*gl_, GetError())
181         .WillOnce(Return(GL_NO_ERROR))
182         .RetiresOnSaturation();
183   }
184 }
185
186 template <>
187 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetProgramInfoLog, 0>(
188     bool /* valid */) {
189   const GLuint kClientVertexShaderId = 5001;
190   const GLuint kServiceVertexShaderId = 6001;
191   const GLuint kClientFragmentShaderId = 5002;
192   const GLuint kServiceFragmentShaderId = 6002;
193   const char* log = "hello";  // Matches auto-generated unit test.
194   DoCreateShader(
195       GL_VERTEX_SHADER, kClientVertexShaderId, kServiceVertexShaderId);
196   DoCreateShader(
197       GL_FRAGMENT_SHADER, kClientFragmentShaderId, kServiceFragmentShaderId);
198
199   TestHelper::SetShaderStates(
200       gl_.get(), GetShader(kClientVertexShaderId), true);
201   TestHelper::SetShaderStates(
202       gl_.get(), GetShader(kClientFragmentShaderId), true);
203
204   InSequence dummy;
205   EXPECT_CALL(*gl_,
206               AttachShader(kServiceProgramId, kServiceVertexShaderId))
207       .Times(1)
208       .RetiresOnSaturation();
209   EXPECT_CALL(*gl_,
210               AttachShader(kServiceProgramId, kServiceFragmentShaderId))
211       .Times(1)
212       .RetiresOnSaturation();
213   EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId))
214       .Times(1)
215       .RetiresOnSaturation();
216   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
217       .WillOnce(SetArgumentPointee<2>(1));
218   EXPECT_CALL(*gl_,
219       GetProgramiv(kServiceProgramId, GL_INFO_LOG_LENGTH, _))
220       .WillOnce(SetArgumentPointee<2>(strlen(log) + 1))
221       .RetiresOnSaturation();
222   EXPECT_CALL(*gl_,
223       GetProgramInfoLog(kServiceProgramId, strlen(log) + 1, _, _))
224       .WillOnce(DoAll(
225           SetArgumentPointee<2>(strlen(log)),
226           SetArrayArgument<3>(log, log + strlen(log) + 1)))
227       .RetiresOnSaturation();
228   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTES, _))
229       .WillOnce(SetArgumentPointee<2>(0));
230   EXPECT_CALL(
231       *gl_,
232       GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
233       .WillOnce(SetArgumentPointee<2>(0));
234   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
235       .WillOnce(SetArgumentPointee<2>(0));
236   EXPECT_CALL(
237       *gl_,
238       GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORM_MAX_LENGTH, _))
239       .WillOnce(SetArgumentPointee<2>(0));
240
241   Program* program = GetProgram(client_program_id_);
242   ASSERT_TRUE(program != NULL);
243
244   cmds::AttachShader attach_cmd;
245   attach_cmd.Init(client_program_id_, kClientVertexShaderId);
246   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
247
248   attach_cmd.Init(client_program_id_, kClientFragmentShaderId);
249   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
250
251   program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
252                 base::Bind(&ShaderCacheCb));
253 };
254
255 template <>
256 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribfv, 0>(
257     bool valid) {
258   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
259   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
260   if (valid) {
261     EXPECT_CALL(*gl_, GetError())
262         .WillOnce(Return(GL_NO_ERROR))
263         .WillOnce(Return(GL_NO_ERROR))
264         .RetiresOnSaturation();
265   }
266 };
267
268 template <>
269 void GLES2DecoderTestBase::SpecializedSetup<cmds::GetVertexAttribiv, 0>(
270     bool valid) {
271   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
272   DoVertexAttribPointer(1, 1, GL_FLOAT, 0, 0);
273   if (valid) {
274     EXPECT_CALL(*gl_, GetError())
275         .WillOnce(Return(GL_NO_ERROR))
276         .WillOnce(Return(GL_NO_ERROR))
277         .RetiresOnSaturation();
278   }
279 };
280
281 template <>
282 void GLES2DecoderTestBase::SpecializedSetup<cmds::RenderbufferStorage, 0>(
283     bool valid) {
284   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
285                     kServiceRenderbufferId);
286   if (valid) {
287     EnsureRenderbufferBound(false);
288     EXPECT_CALL(*gl_, GetError())
289         .WillOnce(Return(GL_NO_ERROR))
290         .RetiresOnSaturation();
291     EXPECT_CALL(*gl_,
292                 RenderbufferStorageEXT(GL_RENDERBUFFER, _, 3, 4))
293         .Times(1)
294         .RetiresOnSaturation();
295     EXPECT_CALL(*gl_, GetError())
296         .WillOnce(Return(GL_NO_ERROR))
297         .RetiresOnSaturation();
298   }
299 }
300
301
302 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h"
303
304 }  // namespace gles2
305 }  // namespace gpu
306