gles2_cmd_format_test_autogen.h revision 4ad1aa43a48567659193a298fad74f55e00b3dd9 
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
3// found in the LICENSE file.
4
5// This file is auto-generated from
6// gpu/command_buffer/build_gles2_cmd_buffer.py
7// It's formatted by clang-format using chromium coding style:
8//    clang-format -i -style=chromium filename
9// DO NOT EDIT!
10
11// This file contains unit tests for gles2 commmands
12// It is included by gles2_cmd_format_test.cc
13
14#ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
15#define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
16
17TEST_F(GLES2FormatTest, ActiveTexture) {
18  cmds::ActiveTexture& cmd = *GetBufferAs<cmds::ActiveTexture>();
19  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
20  EXPECT_EQ(static_cast<uint32>(cmds::ActiveTexture::kCmdId),
21            cmd.header.command);
22  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
23  EXPECT_EQ(static_cast<GLenum>(11), cmd.texture);
24  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
25}
26
27TEST_F(GLES2FormatTest, AttachShader) {
28  cmds::AttachShader& cmd = *GetBufferAs<cmds::AttachShader>();
29  void* next_cmd =
30      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12));
31  EXPECT_EQ(static_cast<uint32>(cmds::AttachShader::kCmdId),
32            cmd.header.command);
33  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
34  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
35  EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
36  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
37}
38
39TEST_F(GLES2FormatTest, BindAttribLocation) {
40  cmds::BindAttribLocation& cmd = *GetBufferAs<cmds::BindAttribLocation>();
41  void* next_cmd = cmd.Set(&cmd,
42                           static_cast<GLuint>(11),
43                           static_cast<GLuint>(12),
44                           static_cast<uint32>(13),
45                           static_cast<uint32>(14),
46                           static_cast<uint32>(15));
47  EXPECT_EQ(static_cast<uint32>(cmds::BindAttribLocation::kCmdId),
48            cmd.header.command);
49  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
50  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
51  EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
52  EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
53  EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
54  EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
55  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
56}
57
58TEST_F(GLES2FormatTest, BindAttribLocationBucket) {
59  cmds::BindAttribLocationBucket& cmd =
60      *GetBufferAs<cmds::BindAttribLocationBucket>();
61  void* next_cmd = cmd.Set(&cmd,
62                           static_cast<GLuint>(11),
63                           static_cast<GLuint>(12),
64                           static_cast<uint32>(13));
65  EXPECT_EQ(static_cast<uint32>(cmds::BindAttribLocationBucket::kCmdId),
66            cmd.header.command);
67  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
68  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
69  EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
70  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
71  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
72}
73
74TEST_F(GLES2FormatTest, BindBuffer) {
75  cmds::BindBuffer& cmd = *GetBufferAs<cmds::BindBuffer>();
76  void* next_cmd =
77      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
78  EXPECT_EQ(static_cast<uint32>(cmds::BindBuffer::kCmdId), cmd.header.command);
79  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
80  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
81  EXPECT_EQ(static_cast<GLuint>(12), cmd.buffer);
82  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
83}
84
85TEST_F(GLES2FormatTest, BindFramebuffer) {
86  cmds::BindFramebuffer& cmd = *GetBufferAs<cmds::BindFramebuffer>();
87  void* next_cmd =
88      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
89  EXPECT_EQ(static_cast<uint32>(cmds::BindFramebuffer::kCmdId),
90            cmd.header.command);
91  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
92  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
93  EXPECT_EQ(static_cast<GLuint>(12), cmd.framebuffer);
94  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
95}
96
97TEST_F(GLES2FormatTest, BindRenderbuffer) {
98  cmds::BindRenderbuffer& cmd = *GetBufferAs<cmds::BindRenderbuffer>();
99  void* next_cmd =
100      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
101  EXPECT_EQ(static_cast<uint32>(cmds::BindRenderbuffer::kCmdId),
102            cmd.header.command);
103  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
104  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
105  EXPECT_EQ(static_cast<GLuint>(12), cmd.renderbuffer);
106  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
107}
108
109TEST_F(GLES2FormatTest, BindTexture) {
110  cmds::BindTexture& cmd = *GetBufferAs<cmds::BindTexture>();
111  void* next_cmd =
112      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
113  EXPECT_EQ(static_cast<uint32>(cmds::BindTexture::kCmdId), cmd.header.command);
114  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
115  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
116  EXPECT_EQ(static_cast<GLuint>(12), cmd.texture);
117  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
118}
119
120TEST_F(GLES2FormatTest, BlendColor) {
121  cmds::BlendColor& cmd = *GetBufferAs<cmds::BlendColor>();
122  void* next_cmd = cmd.Set(&cmd,
123                           static_cast<GLclampf>(11),
124                           static_cast<GLclampf>(12),
125                           static_cast<GLclampf>(13),
126                           static_cast<GLclampf>(14));
127  EXPECT_EQ(static_cast<uint32>(cmds::BlendColor::kCmdId), cmd.header.command);
128  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
129  EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
130  EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
131  EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
132  EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
133  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
134}
135
136TEST_F(GLES2FormatTest, BlendEquation) {
137  cmds::BlendEquation& cmd = *GetBufferAs<cmds::BlendEquation>();
138  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
139  EXPECT_EQ(static_cast<uint32>(cmds::BlendEquation::kCmdId),
140            cmd.header.command);
141  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
142  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
143  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
144}
145
146TEST_F(GLES2FormatTest, BlendEquationSeparate) {
147  cmds::BlendEquationSeparate& cmd =
148      *GetBufferAs<cmds::BlendEquationSeparate>();
149  void* next_cmd =
150      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
151  EXPECT_EQ(static_cast<uint32>(cmds::BlendEquationSeparate::kCmdId),
152            cmd.header.command);
153  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
154  EXPECT_EQ(static_cast<GLenum>(11), cmd.modeRGB);
155  EXPECT_EQ(static_cast<GLenum>(12), cmd.modeAlpha);
156  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
157}
158
159TEST_F(GLES2FormatTest, BlendFunc) {
160  cmds::BlendFunc& cmd = *GetBufferAs<cmds::BlendFunc>();
161  void* next_cmd =
162      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
163  EXPECT_EQ(static_cast<uint32>(cmds::BlendFunc::kCmdId), cmd.header.command);
164  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
165  EXPECT_EQ(static_cast<GLenum>(11), cmd.sfactor);
166  EXPECT_EQ(static_cast<GLenum>(12), cmd.dfactor);
167  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
168}
169
170TEST_F(GLES2FormatTest, BlendFuncSeparate) {
171  cmds::BlendFuncSeparate& cmd = *GetBufferAs<cmds::BlendFuncSeparate>();
172  void* next_cmd = cmd.Set(&cmd,
173                           static_cast<GLenum>(11),
174                           static_cast<GLenum>(12),
175                           static_cast<GLenum>(13),
176                           static_cast<GLenum>(14));
177  EXPECT_EQ(static_cast<uint32>(cmds::BlendFuncSeparate::kCmdId),
178            cmd.header.command);
179  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
180  EXPECT_EQ(static_cast<GLenum>(11), cmd.srcRGB);
181  EXPECT_EQ(static_cast<GLenum>(12), cmd.dstRGB);
182  EXPECT_EQ(static_cast<GLenum>(13), cmd.srcAlpha);
183  EXPECT_EQ(static_cast<GLenum>(14), cmd.dstAlpha);
184  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
185}
186
187TEST_F(GLES2FormatTest, BufferData) {
188  cmds::BufferData& cmd = *GetBufferAs<cmds::BufferData>();
189  void* next_cmd = cmd.Set(&cmd,
190                           static_cast<GLenum>(11),
191                           static_cast<GLsizeiptr>(12),
192                           static_cast<uint32>(13),
193                           static_cast<uint32>(14),
194                           static_cast<GLenum>(15));
195  EXPECT_EQ(static_cast<uint32>(cmds::BufferData::kCmdId), cmd.header.command);
196  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
197  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
198  EXPECT_EQ(static_cast<GLsizeiptr>(12), cmd.size);
199  EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id);
200  EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_offset);
201  EXPECT_EQ(static_cast<GLenum>(15), cmd.usage);
202  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
203}
204
205TEST_F(GLES2FormatTest, BufferSubData) {
206  cmds::BufferSubData& cmd = *GetBufferAs<cmds::BufferSubData>();
207  void* next_cmd = cmd.Set(&cmd,
208                           static_cast<GLenum>(11),
209                           static_cast<GLintptr>(12),
210                           static_cast<GLsizeiptr>(13),
211                           static_cast<uint32>(14),
212                           static_cast<uint32>(15));
213  EXPECT_EQ(static_cast<uint32>(cmds::BufferSubData::kCmdId),
214            cmd.header.command);
215  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
216  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
217  EXPECT_EQ(static_cast<GLintptr>(12), cmd.offset);
218  EXPECT_EQ(static_cast<GLsizeiptr>(13), cmd.size);
219  EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_id);
220  EXPECT_EQ(static_cast<uint32>(15), cmd.data_shm_offset);
221  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
222}
223
224TEST_F(GLES2FormatTest, CheckFramebufferStatus) {
225  cmds::CheckFramebufferStatus& cmd =
226      *GetBufferAs<cmds::CheckFramebufferStatus>();
227  void* next_cmd = cmd.Set(&cmd,
228                           static_cast<GLenum>(11),
229                           static_cast<uint32>(12),
230                           static_cast<uint32>(13));
231  EXPECT_EQ(static_cast<uint32>(cmds::CheckFramebufferStatus::kCmdId),
232            cmd.header.command);
233  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
234  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
235  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
236  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
237  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
238}
239
240TEST_F(GLES2FormatTest, Clear) {
241  cmds::Clear& cmd = *GetBufferAs<cmds::Clear>();
242  void* next_cmd = cmd.Set(&cmd, static_cast<GLbitfield>(11));
243  EXPECT_EQ(static_cast<uint32>(cmds::Clear::kCmdId), cmd.header.command);
244  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
245  EXPECT_EQ(static_cast<GLbitfield>(11), cmd.mask);
246  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
247}
248
249TEST_F(GLES2FormatTest, ClearColor) {
250  cmds::ClearColor& cmd = *GetBufferAs<cmds::ClearColor>();
251  void* next_cmd = cmd.Set(&cmd,
252                           static_cast<GLclampf>(11),
253                           static_cast<GLclampf>(12),
254                           static_cast<GLclampf>(13),
255                           static_cast<GLclampf>(14));
256  EXPECT_EQ(static_cast<uint32>(cmds::ClearColor::kCmdId), cmd.header.command);
257  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
258  EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
259  EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
260  EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
261  EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
262  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
263}
264
265TEST_F(GLES2FormatTest, ClearDepthf) {
266  cmds::ClearDepthf& cmd = *GetBufferAs<cmds::ClearDepthf>();
267  void* next_cmd = cmd.Set(&cmd, static_cast<GLclampf>(11));
268  EXPECT_EQ(static_cast<uint32>(cmds::ClearDepthf::kCmdId), cmd.header.command);
269  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
270  EXPECT_EQ(static_cast<GLclampf>(11), cmd.depth);
271  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
272}
273
274TEST_F(GLES2FormatTest, ClearStencil) {
275  cmds::ClearStencil& cmd = *GetBufferAs<cmds::ClearStencil>();
276  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11));
277  EXPECT_EQ(static_cast<uint32>(cmds::ClearStencil::kCmdId),
278            cmd.header.command);
279  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
280  EXPECT_EQ(static_cast<GLint>(11), cmd.s);
281  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
282}
283
284TEST_F(GLES2FormatTest, ColorMask) {
285  cmds::ColorMask& cmd = *GetBufferAs<cmds::ColorMask>();
286  void* next_cmd = cmd.Set(&cmd,
287                           static_cast<GLboolean>(11),
288                           static_cast<GLboolean>(12),
289                           static_cast<GLboolean>(13),
290                           static_cast<GLboolean>(14));
291  EXPECT_EQ(static_cast<uint32>(cmds::ColorMask::kCmdId), cmd.header.command);
292  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
293  EXPECT_EQ(static_cast<GLboolean>(11), cmd.red);
294  EXPECT_EQ(static_cast<GLboolean>(12), cmd.green);
295  EXPECT_EQ(static_cast<GLboolean>(13), cmd.blue);
296  EXPECT_EQ(static_cast<GLboolean>(14), cmd.alpha);
297  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
298}
299
300TEST_F(GLES2FormatTest, CompileShader) {
301  cmds::CompileShader& cmd = *GetBufferAs<cmds::CompileShader>();
302  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
303  EXPECT_EQ(static_cast<uint32>(cmds::CompileShader::kCmdId),
304            cmd.header.command);
305  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
306  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
307  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
308}
309
310TEST_F(GLES2FormatTest, CompressedTexImage2D) {
311  cmds::CompressedTexImage2D& cmd = *GetBufferAs<cmds::CompressedTexImage2D>();
312  void* next_cmd = cmd.Set(&cmd,
313                           static_cast<GLenum>(11),
314                           static_cast<GLint>(12),
315                           static_cast<GLenum>(13),
316                           static_cast<GLsizei>(14),
317                           static_cast<GLsizei>(15),
318                           static_cast<GLint>(16),
319                           static_cast<GLsizei>(17),
320                           static_cast<uint32>(18),
321                           static_cast<uint32>(19));
322  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexImage2D::kCmdId),
323            cmd.header.command);
324  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
325  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
326  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
327  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
328  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
329  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
330  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
331  EXPECT_EQ(static_cast<GLsizei>(17), cmd.imageSize);
332  EXPECT_EQ(static_cast<uint32>(18), cmd.data_shm_id);
333  EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_offset);
334  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
335}
336
337TEST_F(GLES2FormatTest, CompressedTexImage2DBucket) {
338  cmds::CompressedTexImage2DBucket& cmd =
339      *GetBufferAs<cmds::CompressedTexImage2DBucket>();
340  void* next_cmd = cmd.Set(&cmd,
341                           static_cast<GLenum>(11),
342                           static_cast<GLint>(12),
343                           static_cast<GLenum>(13),
344                           static_cast<GLsizei>(14),
345                           static_cast<GLsizei>(15),
346                           static_cast<GLint>(16),
347                           static_cast<GLuint>(17));
348  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexImage2DBucket::kCmdId),
349            cmd.header.command);
350  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
351  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
352  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
353  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
354  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
355  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
356  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
357  EXPECT_EQ(static_cast<GLuint>(17), cmd.bucket_id);
358  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
359}
360
361TEST_F(GLES2FormatTest, CompressedTexSubImage2D) {
362  cmds::CompressedTexSubImage2D& cmd =
363      *GetBufferAs<cmds::CompressedTexSubImage2D>();
364  void* next_cmd = cmd.Set(&cmd,
365                           static_cast<GLenum>(11),
366                           static_cast<GLint>(12),
367                           static_cast<GLint>(13),
368                           static_cast<GLint>(14),
369                           static_cast<GLsizei>(15),
370                           static_cast<GLsizei>(16),
371                           static_cast<GLenum>(17),
372                           static_cast<GLsizei>(18),
373                           static_cast<uint32>(19),
374                           static_cast<uint32>(20));
375  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexSubImage2D::kCmdId),
376            cmd.header.command);
377  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
378  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
379  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
380  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
381  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
382  EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
383  EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
384  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
385  EXPECT_EQ(static_cast<GLsizei>(18), cmd.imageSize);
386  EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
387  EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
388  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
389}
390
391TEST_F(GLES2FormatTest, CompressedTexSubImage2DBucket) {
392  cmds::CompressedTexSubImage2DBucket& cmd =
393      *GetBufferAs<cmds::CompressedTexSubImage2DBucket>();
394  void* next_cmd = cmd.Set(&cmd,
395                           static_cast<GLenum>(11),
396                           static_cast<GLint>(12),
397                           static_cast<GLint>(13),
398                           static_cast<GLint>(14),
399                           static_cast<GLsizei>(15),
400                           static_cast<GLsizei>(16),
401                           static_cast<GLenum>(17),
402                           static_cast<GLuint>(18));
403  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexSubImage2DBucket::kCmdId),
404            cmd.header.command);
405  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
406  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
407  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
408  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
409  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
410  EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
411  EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
412  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
413  EXPECT_EQ(static_cast<GLuint>(18), cmd.bucket_id);
414  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
415}
416
417TEST_F(GLES2FormatTest, CopyTexImage2D) {
418  cmds::CopyTexImage2D& cmd = *GetBufferAs<cmds::CopyTexImage2D>();
419  void* next_cmd = cmd.Set(&cmd,
420                           static_cast<GLenum>(11),
421                           static_cast<GLint>(12),
422                           static_cast<GLenum>(13),
423                           static_cast<GLint>(14),
424                           static_cast<GLint>(15),
425                           static_cast<GLsizei>(16),
426                           static_cast<GLsizei>(17),
427                           static_cast<GLint>(18));
428  EXPECT_EQ(static_cast<uint32>(cmds::CopyTexImage2D::kCmdId),
429            cmd.header.command);
430  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
431  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
432  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
433  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
434  EXPECT_EQ(static_cast<GLint>(14), cmd.x);
435  EXPECT_EQ(static_cast<GLint>(15), cmd.y);
436  EXPECT_EQ(static_cast<GLsizei>(16), cmd.width);
437  EXPECT_EQ(static_cast<GLsizei>(17), cmd.height);
438  EXPECT_EQ(static_cast<GLint>(18), cmd.border);
439  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
440}
441
442TEST_F(GLES2FormatTest, CopyTexSubImage2D) {
443  cmds::CopyTexSubImage2D& cmd = *GetBufferAs<cmds::CopyTexSubImage2D>();
444  void* next_cmd = cmd.Set(&cmd,
445                           static_cast<GLenum>(11),
446                           static_cast<GLint>(12),
447                           static_cast<GLint>(13),
448                           static_cast<GLint>(14),
449                           static_cast<GLint>(15),
450                           static_cast<GLint>(16),
451                           static_cast<GLsizei>(17),
452                           static_cast<GLsizei>(18));
453  EXPECT_EQ(static_cast<uint32>(cmds::CopyTexSubImage2D::kCmdId),
454            cmd.header.command);
455  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
456  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
457  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
458  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
459  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
460  EXPECT_EQ(static_cast<GLint>(15), cmd.x);
461  EXPECT_EQ(static_cast<GLint>(16), cmd.y);
462  EXPECT_EQ(static_cast<GLsizei>(17), cmd.width);
463  EXPECT_EQ(static_cast<GLsizei>(18), cmd.height);
464  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
465}
466
467TEST_F(GLES2FormatTest, CreateProgram) {
468  cmds::CreateProgram& cmd = *GetBufferAs<cmds::CreateProgram>();
469  void* next_cmd = cmd.Set(&cmd, static_cast<uint32>(11));
470  EXPECT_EQ(static_cast<uint32>(cmds::CreateProgram::kCmdId),
471            cmd.header.command);
472  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
473  EXPECT_EQ(static_cast<uint32>(11), cmd.client_id);
474  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
475}
476
477TEST_F(GLES2FormatTest, CreateShader) {
478  cmds::CreateShader& cmd = *GetBufferAs<cmds::CreateShader>();
479  void* next_cmd =
480      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<uint32>(12));
481  EXPECT_EQ(static_cast<uint32>(cmds::CreateShader::kCmdId),
482            cmd.header.command);
483  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
484  EXPECT_EQ(static_cast<GLenum>(11), cmd.type);
485  EXPECT_EQ(static_cast<uint32>(12), cmd.client_id);
486  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
487}
488
489TEST_F(GLES2FormatTest, CullFace) {
490  cmds::CullFace& cmd = *GetBufferAs<cmds::CullFace>();
491  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
492  EXPECT_EQ(static_cast<uint32>(cmds::CullFace::kCmdId), cmd.header.command);
493  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
494  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
495  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
496}
497
498TEST_F(GLES2FormatTest, DeleteBuffers) {
499  cmds::DeleteBuffers& cmd = *GetBufferAs<cmds::DeleteBuffers>();
500  void* next_cmd = cmd.Set(&cmd,
501                           static_cast<GLsizei>(11),
502                           static_cast<uint32>(12),
503                           static_cast<uint32>(13));
504  EXPECT_EQ(static_cast<uint32>(cmds::DeleteBuffers::kCmdId),
505            cmd.header.command);
506  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
507  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
508  EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
509  EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
510  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
511}
512
513TEST_F(GLES2FormatTest, DeleteBuffersImmediate) {
514  static GLuint ids[] = {12, 23, 34, };
515  cmds::DeleteBuffersImmediate& cmd =
516      *GetBufferAs<cmds::DeleteBuffersImmediate>();
517  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
518  EXPECT_EQ(static_cast<uint32>(cmds::DeleteBuffersImmediate::kCmdId),
519            cmd.header.command);
520  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
521            cmd.header.size * 4u);
522  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
523  CheckBytesWrittenMatchesExpectedSize(
524      next_cmd,
525      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
526  // TODO(gman): Check that ids were inserted;
527}
528
529TEST_F(GLES2FormatTest, DeleteFramebuffers) {
530  cmds::DeleteFramebuffers& cmd = *GetBufferAs<cmds::DeleteFramebuffers>();
531  void* next_cmd = cmd.Set(&cmd,
532                           static_cast<GLsizei>(11),
533                           static_cast<uint32>(12),
534                           static_cast<uint32>(13));
535  EXPECT_EQ(static_cast<uint32>(cmds::DeleteFramebuffers::kCmdId),
536            cmd.header.command);
537  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
538  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
539  EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
540  EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
541  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
542}
543
544TEST_F(GLES2FormatTest, DeleteFramebuffersImmediate) {
545  static GLuint ids[] = {12, 23, 34, };
546  cmds::DeleteFramebuffersImmediate& cmd =
547      *GetBufferAs<cmds::DeleteFramebuffersImmediate>();
548  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
549  EXPECT_EQ(static_cast<uint32>(cmds::DeleteFramebuffersImmediate::kCmdId),
550            cmd.header.command);
551  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
552            cmd.header.size * 4u);
553  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
554  CheckBytesWrittenMatchesExpectedSize(
555      next_cmd,
556      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
557  // TODO(gman): Check that ids were inserted;
558}
559
560TEST_F(GLES2FormatTest, DeleteProgram) {
561  cmds::DeleteProgram& cmd = *GetBufferAs<cmds::DeleteProgram>();
562  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
563  EXPECT_EQ(static_cast<uint32>(cmds::DeleteProgram::kCmdId),
564            cmd.header.command);
565  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
566  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
567  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
568}
569
570TEST_F(GLES2FormatTest, DeleteRenderbuffers) {
571  cmds::DeleteRenderbuffers& cmd = *GetBufferAs<cmds::DeleteRenderbuffers>();
572  void* next_cmd = cmd.Set(&cmd,
573                           static_cast<GLsizei>(11),
574                           static_cast<uint32>(12),
575                           static_cast<uint32>(13));
576  EXPECT_EQ(static_cast<uint32>(cmds::DeleteRenderbuffers::kCmdId),
577            cmd.header.command);
578  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
579  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
580  EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
581  EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
582  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
583}
584
585TEST_F(GLES2FormatTest, DeleteRenderbuffersImmediate) {
586  static GLuint ids[] = {12, 23, 34, };
587  cmds::DeleteRenderbuffersImmediate& cmd =
588      *GetBufferAs<cmds::DeleteRenderbuffersImmediate>();
589  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
590  EXPECT_EQ(static_cast<uint32>(cmds::DeleteRenderbuffersImmediate::kCmdId),
591            cmd.header.command);
592  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
593            cmd.header.size * 4u);
594  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
595  CheckBytesWrittenMatchesExpectedSize(
596      next_cmd,
597      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
598  // TODO(gman): Check that ids were inserted;
599}
600
601TEST_F(GLES2FormatTest, DeleteShader) {
602  cmds::DeleteShader& cmd = *GetBufferAs<cmds::DeleteShader>();
603  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
604  EXPECT_EQ(static_cast<uint32>(cmds::DeleteShader::kCmdId),
605            cmd.header.command);
606  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
607  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
608  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
609}
610
611TEST_F(GLES2FormatTest, DeleteTextures) {
612  cmds::DeleteTextures& cmd = *GetBufferAs<cmds::DeleteTextures>();
613  void* next_cmd = cmd.Set(&cmd,
614                           static_cast<GLsizei>(11),
615                           static_cast<uint32>(12),
616                           static_cast<uint32>(13));
617  EXPECT_EQ(static_cast<uint32>(cmds::DeleteTextures::kCmdId),
618            cmd.header.command);
619  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
620  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
621  EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
622  EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
623  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
624}
625
626TEST_F(GLES2FormatTest, DeleteTexturesImmediate) {
627  static GLuint ids[] = {12, 23, 34, };
628  cmds::DeleteTexturesImmediate& cmd =
629      *GetBufferAs<cmds::DeleteTexturesImmediate>();
630  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
631  EXPECT_EQ(static_cast<uint32>(cmds::DeleteTexturesImmediate::kCmdId),
632            cmd.header.command);
633  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
634            cmd.header.size * 4u);
635  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
636  CheckBytesWrittenMatchesExpectedSize(
637      next_cmd,
638      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
639  // TODO(gman): Check that ids were inserted;
640}
641
642TEST_F(GLES2FormatTest, DepthFunc) {
643  cmds::DepthFunc& cmd = *GetBufferAs<cmds::DepthFunc>();
644  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
645  EXPECT_EQ(static_cast<uint32>(cmds::DepthFunc::kCmdId), cmd.header.command);
646  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
647  EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
648  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
649}
650
651TEST_F(GLES2FormatTest, DepthMask) {
652  cmds::DepthMask& cmd = *GetBufferAs<cmds::DepthMask>();
653  void* next_cmd = cmd.Set(&cmd, static_cast<GLboolean>(11));
654  EXPECT_EQ(static_cast<uint32>(cmds::DepthMask::kCmdId), cmd.header.command);
655  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
656  EXPECT_EQ(static_cast<GLboolean>(11), cmd.flag);
657  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
658}
659
660TEST_F(GLES2FormatTest, DepthRangef) {
661  cmds::DepthRangef& cmd = *GetBufferAs<cmds::DepthRangef>();
662  void* next_cmd =
663      cmd.Set(&cmd, static_cast<GLclampf>(11), static_cast<GLclampf>(12));
664  EXPECT_EQ(static_cast<uint32>(cmds::DepthRangef::kCmdId), cmd.header.command);
665  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
666  EXPECT_EQ(static_cast<GLclampf>(11), cmd.zNear);
667  EXPECT_EQ(static_cast<GLclampf>(12), cmd.zFar);
668  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
669}
670
671TEST_F(GLES2FormatTest, DetachShader) {
672  cmds::DetachShader& cmd = *GetBufferAs<cmds::DetachShader>();
673  void* next_cmd =
674      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12));
675  EXPECT_EQ(static_cast<uint32>(cmds::DetachShader::kCmdId),
676            cmd.header.command);
677  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
678  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
679  EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
680  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
681}
682
683TEST_F(GLES2FormatTest, Disable) {
684  cmds::Disable& cmd = *GetBufferAs<cmds::Disable>();
685  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
686  EXPECT_EQ(static_cast<uint32>(cmds::Disable::kCmdId), cmd.header.command);
687  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
688  EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
689  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
690}
691
692TEST_F(GLES2FormatTest, DisableVertexAttribArray) {
693  cmds::DisableVertexAttribArray& cmd =
694      *GetBufferAs<cmds::DisableVertexAttribArray>();
695  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
696  EXPECT_EQ(static_cast<uint32>(cmds::DisableVertexAttribArray::kCmdId),
697            cmd.header.command);
698  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
699  EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
700  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
701}
702
703TEST_F(GLES2FormatTest, DrawArrays) {
704  cmds::DrawArrays& cmd = *GetBufferAs<cmds::DrawArrays>();
705  void* next_cmd = cmd.Set(&cmd,
706                           static_cast<GLenum>(11),
707                           static_cast<GLint>(12),
708                           static_cast<GLsizei>(13));
709  EXPECT_EQ(static_cast<uint32>(cmds::DrawArrays::kCmdId), cmd.header.command);
710  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
711  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
712  EXPECT_EQ(static_cast<GLint>(12), cmd.first);
713  EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
714  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
715}
716
717TEST_F(GLES2FormatTest, DrawElements) {
718  cmds::DrawElements& cmd = *GetBufferAs<cmds::DrawElements>();
719  void* next_cmd = cmd.Set(&cmd,
720                           static_cast<GLenum>(11),
721                           static_cast<GLsizei>(12),
722                           static_cast<GLenum>(13),
723                           static_cast<GLuint>(14));
724  EXPECT_EQ(static_cast<uint32>(cmds::DrawElements::kCmdId),
725            cmd.header.command);
726  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
727  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
728  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
729  EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
730  EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
731  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
732}
733
734TEST_F(GLES2FormatTest, Enable) {
735  cmds::Enable& cmd = *GetBufferAs<cmds::Enable>();
736  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
737  EXPECT_EQ(static_cast<uint32>(cmds::Enable::kCmdId), cmd.header.command);
738  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
739  EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
740  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
741}
742
743TEST_F(GLES2FormatTest, EnableVertexAttribArray) {
744  cmds::EnableVertexAttribArray& cmd =
745      *GetBufferAs<cmds::EnableVertexAttribArray>();
746  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
747  EXPECT_EQ(static_cast<uint32>(cmds::EnableVertexAttribArray::kCmdId),
748            cmd.header.command);
749  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
750  EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
751  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
752}
753
754TEST_F(GLES2FormatTest, Finish) {
755  cmds::Finish& cmd = *GetBufferAs<cmds::Finish>();
756  void* next_cmd = cmd.Set(&cmd);
757  EXPECT_EQ(static_cast<uint32>(cmds::Finish::kCmdId), cmd.header.command);
758  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
759  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
760}
761
762TEST_F(GLES2FormatTest, Flush) {
763  cmds::Flush& cmd = *GetBufferAs<cmds::Flush>();
764  void* next_cmd = cmd.Set(&cmd);
765  EXPECT_EQ(static_cast<uint32>(cmds::Flush::kCmdId), cmd.header.command);
766  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
767  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
768}
769
770TEST_F(GLES2FormatTest, FramebufferRenderbuffer) {
771  cmds::FramebufferRenderbuffer& cmd =
772      *GetBufferAs<cmds::FramebufferRenderbuffer>();
773  void* next_cmd = cmd.Set(&cmd,
774                           static_cast<GLenum>(11),
775                           static_cast<GLenum>(12),
776                           static_cast<GLenum>(13),
777                           static_cast<GLuint>(14));
778  EXPECT_EQ(static_cast<uint32>(cmds::FramebufferRenderbuffer::kCmdId),
779            cmd.header.command);
780  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
781  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
782  EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
783  EXPECT_EQ(static_cast<GLenum>(13), cmd.renderbuffertarget);
784  EXPECT_EQ(static_cast<GLuint>(14), cmd.renderbuffer);
785  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
786}
787
788TEST_F(GLES2FormatTest, FramebufferTexture2D) {
789  cmds::FramebufferTexture2D& cmd = *GetBufferAs<cmds::FramebufferTexture2D>();
790  void* next_cmd = cmd.Set(&cmd,
791                           static_cast<GLenum>(11),
792                           static_cast<GLenum>(12),
793                           static_cast<GLenum>(13),
794                           static_cast<GLuint>(14),
795                           static_cast<GLint>(15));
796  EXPECT_EQ(static_cast<uint32>(cmds::FramebufferTexture2D::kCmdId),
797            cmd.header.command);
798  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
799  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
800  EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
801  EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
802  EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
803  EXPECT_EQ(static_cast<GLint>(15), cmd.level);
804  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
805}
806
807TEST_F(GLES2FormatTest, FrontFace) {
808  cmds::FrontFace& cmd = *GetBufferAs<cmds::FrontFace>();
809  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
810  EXPECT_EQ(static_cast<uint32>(cmds::FrontFace::kCmdId), cmd.header.command);
811  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
812  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
813  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
814}
815
816TEST_F(GLES2FormatTest, GenBuffers) {
817  cmds::GenBuffers& cmd = *GetBufferAs<cmds::GenBuffers>();
818  void* next_cmd = cmd.Set(&cmd,
819                           static_cast<GLsizei>(11),
820                           static_cast<uint32>(12),
821                           static_cast<uint32>(13));
822  EXPECT_EQ(static_cast<uint32>(cmds::GenBuffers::kCmdId), cmd.header.command);
823  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
824  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
825  EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
826  EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
827  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
828}
829
830TEST_F(GLES2FormatTest, GenBuffersImmediate) {
831  static GLuint ids[] = {12, 23, 34, };
832  cmds::GenBuffersImmediate& cmd = *GetBufferAs<cmds::GenBuffersImmediate>();
833  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
834  EXPECT_EQ(static_cast<uint32>(cmds::GenBuffersImmediate::kCmdId),
835            cmd.header.command);
836  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
837            cmd.header.size * 4u);
838  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
839  CheckBytesWrittenMatchesExpectedSize(
840      next_cmd,
841      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
842  // TODO(gman): Check that ids were inserted;
843}
844
845TEST_F(GLES2FormatTest, GenerateMipmap) {
846  cmds::GenerateMipmap& cmd = *GetBufferAs<cmds::GenerateMipmap>();
847  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
848  EXPECT_EQ(static_cast<uint32>(cmds::GenerateMipmap::kCmdId),
849            cmd.header.command);
850  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
851  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
852  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
853}
854
855TEST_F(GLES2FormatTest, GenFramebuffers) {
856  cmds::GenFramebuffers& cmd = *GetBufferAs<cmds::GenFramebuffers>();
857  void* next_cmd = cmd.Set(&cmd,
858                           static_cast<GLsizei>(11),
859                           static_cast<uint32>(12),
860                           static_cast<uint32>(13));
861  EXPECT_EQ(static_cast<uint32>(cmds::GenFramebuffers::kCmdId),
862            cmd.header.command);
863  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
864  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
865  EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
866  EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
867  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
868}
869
870TEST_F(GLES2FormatTest, GenFramebuffersImmediate) {
871  static GLuint ids[] = {12, 23, 34, };
872  cmds::GenFramebuffersImmediate& cmd =
873      *GetBufferAs<cmds::GenFramebuffersImmediate>();
874  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
875  EXPECT_EQ(static_cast<uint32>(cmds::GenFramebuffersImmediate::kCmdId),
876            cmd.header.command);
877  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
878            cmd.header.size * 4u);
879  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
880  CheckBytesWrittenMatchesExpectedSize(
881      next_cmd,
882      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
883  // TODO(gman): Check that ids were inserted;
884}
885
886TEST_F(GLES2FormatTest, GenRenderbuffers) {
887  cmds::GenRenderbuffers& cmd = *GetBufferAs<cmds::GenRenderbuffers>();
888  void* next_cmd = cmd.Set(&cmd,
889                           static_cast<GLsizei>(11),
890                           static_cast<uint32>(12),
891                           static_cast<uint32>(13));
892  EXPECT_EQ(static_cast<uint32>(cmds::GenRenderbuffers::kCmdId),
893            cmd.header.command);
894  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
895  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
896  EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
897  EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
898  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
899}
900
901TEST_F(GLES2FormatTest, GenRenderbuffersImmediate) {
902  static GLuint ids[] = {12, 23, 34, };
903  cmds::GenRenderbuffersImmediate& cmd =
904      *GetBufferAs<cmds::GenRenderbuffersImmediate>();
905  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
906  EXPECT_EQ(static_cast<uint32>(cmds::GenRenderbuffersImmediate::kCmdId),
907            cmd.header.command);
908  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
909            cmd.header.size * 4u);
910  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
911  CheckBytesWrittenMatchesExpectedSize(
912      next_cmd,
913      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
914  // TODO(gman): Check that ids were inserted;
915}
916
917TEST_F(GLES2FormatTest, GenTextures) {
918  cmds::GenTextures& cmd = *GetBufferAs<cmds::GenTextures>();
919  void* next_cmd = cmd.Set(&cmd,
920                           static_cast<GLsizei>(11),
921                           static_cast<uint32>(12),
922                           static_cast<uint32>(13));
923  EXPECT_EQ(static_cast<uint32>(cmds::GenTextures::kCmdId), cmd.header.command);
924  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
925  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
926  EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
927  EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
928  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
929}
930
931TEST_F(GLES2FormatTest, GenTexturesImmediate) {
932  static GLuint ids[] = {12, 23, 34, };
933  cmds::GenTexturesImmediate& cmd = *GetBufferAs<cmds::GenTexturesImmediate>();
934  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
935  EXPECT_EQ(static_cast<uint32>(cmds::GenTexturesImmediate::kCmdId),
936            cmd.header.command);
937  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
938            cmd.header.size * 4u);
939  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
940  CheckBytesWrittenMatchesExpectedSize(
941      next_cmd,
942      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
943  // TODO(gman): Check that ids were inserted;
944}
945
946TEST_F(GLES2FormatTest, GetActiveAttrib) {
947  cmds::GetActiveAttrib& cmd = *GetBufferAs<cmds::GetActiveAttrib>();
948  void* next_cmd = cmd.Set(&cmd,
949                           static_cast<GLuint>(11),
950                           static_cast<GLuint>(12),
951                           static_cast<uint32>(13),
952                           static_cast<uint32>(14),
953                           static_cast<uint32>(15));
954  EXPECT_EQ(static_cast<uint32>(cmds::GetActiveAttrib::kCmdId),
955            cmd.header.command);
956  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
957  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
958  EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
959  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
960  EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
961  EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
962  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
963}
964
965TEST_F(GLES2FormatTest, GetActiveUniform) {
966  cmds::GetActiveUniform& cmd = *GetBufferAs<cmds::GetActiveUniform>();
967  void* next_cmd = cmd.Set(&cmd,
968                           static_cast<GLuint>(11),
969                           static_cast<GLuint>(12),
970                           static_cast<uint32>(13),
971                           static_cast<uint32>(14),
972                           static_cast<uint32>(15));
973  EXPECT_EQ(static_cast<uint32>(cmds::GetActiveUniform::kCmdId),
974            cmd.header.command);
975  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
976  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
977  EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
978  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
979  EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
980  EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
981  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
982}
983
984TEST_F(GLES2FormatTest, GetAttachedShaders) {
985  cmds::GetAttachedShaders& cmd = *GetBufferAs<cmds::GetAttachedShaders>();
986  void* next_cmd = cmd.Set(&cmd,
987                           static_cast<GLuint>(11),
988                           static_cast<uint32>(12),
989                           static_cast<uint32>(13),
990                           static_cast<uint32>(14));
991  EXPECT_EQ(static_cast<uint32>(cmds::GetAttachedShaders::kCmdId),
992            cmd.header.command);
993  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
994  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
995  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
996  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
997  EXPECT_EQ(static_cast<uint32>(14), cmd.result_size);
998  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
999}
1000
1001// TODO(gman): Write test for GetAttribLocation
1002// TODO(gman): Write test for GetAttribLocationBucket
1003TEST_F(GLES2FormatTest, GetBooleanv) {
1004  cmds::GetBooleanv& cmd = *GetBufferAs<cmds::GetBooleanv>();
1005  void* next_cmd = cmd.Set(&cmd,
1006                           static_cast<GLenum>(11),
1007                           static_cast<uint32>(12),
1008                           static_cast<uint32>(13));
1009  EXPECT_EQ(static_cast<uint32>(cmds::GetBooleanv::kCmdId), cmd.header.command);
1010  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1011  EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1012  EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
1013  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
1014  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1015}
1016
1017TEST_F(GLES2FormatTest, GetBufferParameteriv) {
1018  cmds::GetBufferParameteriv& cmd = *GetBufferAs<cmds::GetBufferParameteriv>();
1019  void* next_cmd = cmd.Set(&cmd,
1020                           static_cast<GLenum>(11),
1021                           static_cast<GLenum>(12),
1022                           static_cast<uint32>(13),
1023                           static_cast<uint32>(14));
1024  EXPECT_EQ(static_cast<uint32>(cmds::GetBufferParameteriv::kCmdId),
1025            cmd.header.command);
1026  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1027  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1028  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1029  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1030  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1031  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1032}
1033
1034TEST_F(GLES2FormatTest, GetError) {
1035  cmds::GetError& cmd = *GetBufferAs<cmds::GetError>();
1036  void* next_cmd =
1037      cmd.Set(&cmd, static_cast<uint32>(11), static_cast<uint32>(12));
1038  EXPECT_EQ(static_cast<uint32>(cmds::GetError::kCmdId), cmd.header.command);
1039  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1040  EXPECT_EQ(static_cast<uint32>(11), cmd.result_shm_id);
1041  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_offset);
1042  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1043}
1044
1045TEST_F(GLES2FormatTest, GetFloatv) {
1046  cmds::GetFloatv& cmd = *GetBufferAs<cmds::GetFloatv>();
1047  void* next_cmd = cmd.Set(&cmd,
1048                           static_cast<GLenum>(11),
1049                           static_cast<uint32>(12),
1050                           static_cast<uint32>(13));
1051  EXPECT_EQ(static_cast<uint32>(cmds::GetFloatv::kCmdId), cmd.header.command);
1052  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1053  EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1054  EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
1055  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
1056  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1057}
1058
1059TEST_F(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
1060  cmds::GetFramebufferAttachmentParameteriv& cmd =
1061      *GetBufferAs<cmds::GetFramebufferAttachmentParameteriv>();
1062  void* next_cmd = cmd.Set(&cmd,
1063                           static_cast<GLenum>(11),
1064                           static_cast<GLenum>(12),
1065                           static_cast<GLenum>(13),
1066                           static_cast<uint32>(14),
1067                           static_cast<uint32>(15));
1068  EXPECT_EQ(
1069      static_cast<uint32>(cmds::GetFramebufferAttachmentParameteriv::kCmdId),
1070      cmd.header.command);
1071  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1072  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1073  EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
1074  EXPECT_EQ(static_cast<GLenum>(13), cmd.pname);
1075  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_id);
1076  EXPECT_EQ(static_cast<uint32>(15), cmd.params_shm_offset);
1077  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1078}
1079
1080TEST_F(GLES2FormatTest, GetIntegerv) {
1081  cmds::GetIntegerv& cmd = *GetBufferAs<cmds::GetIntegerv>();
1082  void* next_cmd = cmd.Set(&cmd,
1083                           static_cast<GLenum>(11),
1084                           static_cast<uint32>(12),
1085                           static_cast<uint32>(13));
1086  EXPECT_EQ(static_cast<uint32>(cmds::GetIntegerv::kCmdId), cmd.header.command);
1087  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1088  EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1089  EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
1090  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
1091  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1092}
1093
1094TEST_F(GLES2FormatTest, GetProgramiv) {
1095  cmds::GetProgramiv& cmd = *GetBufferAs<cmds::GetProgramiv>();
1096  void* next_cmd = cmd.Set(&cmd,
1097                           static_cast<GLuint>(11),
1098                           static_cast<GLenum>(12),
1099                           static_cast<uint32>(13),
1100                           static_cast<uint32>(14));
1101  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramiv::kCmdId),
1102            cmd.header.command);
1103  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1104  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1105  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1106  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1107  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1108  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1109}
1110
1111TEST_F(GLES2FormatTest, GetProgramInfoLog) {
1112  cmds::GetProgramInfoLog& cmd = *GetBufferAs<cmds::GetProgramInfoLog>();
1113  void* next_cmd =
1114      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
1115  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramInfoLog::kCmdId),
1116            cmd.header.command);
1117  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1118  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1119  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1120  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1121}
1122
1123TEST_F(GLES2FormatTest, GetRenderbufferParameteriv) {
1124  cmds::GetRenderbufferParameteriv& cmd =
1125      *GetBufferAs<cmds::GetRenderbufferParameteriv>();
1126  void* next_cmd = cmd.Set(&cmd,
1127                           static_cast<GLenum>(11),
1128                           static_cast<GLenum>(12),
1129                           static_cast<uint32>(13),
1130                           static_cast<uint32>(14));
1131  EXPECT_EQ(static_cast<uint32>(cmds::GetRenderbufferParameteriv::kCmdId),
1132            cmd.header.command);
1133  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1134  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1135  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1136  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1137  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1138  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1139}
1140
1141TEST_F(GLES2FormatTest, GetShaderiv) {
1142  cmds::GetShaderiv& cmd = *GetBufferAs<cmds::GetShaderiv>();
1143  void* next_cmd = cmd.Set(&cmd,
1144                           static_cast<GLuint>(11),
1145                           static_cast<GLenum>(12),
1146                           static_cast<uint32>(13),
1147                           static_cast<uint32>(14));
1148  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderiv::kCmdId), cmd.header.command);
1149  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1150  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1151  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1152  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1153  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1154  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1155}
1156
1157TEST_F(GLES2FormatTest, GetShaderInfoLog) {
1158  cmds::GetShaderInfoLog& cmd = *GetBufferAs<cmds::GetShaderInfoLog>();
1159  void* next_cmd =
1160      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
1161  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderInfoLog::kCmdId),
1162            cmd.header.command);
1163  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1164  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1165  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1166  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1167}
1168
1169TEST_F(GLES2FormatTest, GetShaderPrecisionFormat) {
1170  cmds::GetShaderPrecisionFormat& cmd =
1171      *GetBufferAs<cmds::GetShaderPrecisionFormat>();
1172  void* next_cmd = cmd.Set(&cmd,
1173                           static_cast<GLenum>(11),
1174                           static_cast<GLenum>(12),
1175                           static_cast<uint32>(13),
1176                           static_cast<uint32>(14));
1177  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderPrecisionFormat::kCmdId),
1178            cmd.header.command);
1179  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1180  EXPECT_EQ(static_cast<GLenum>(11), cmd.shadertype);
1181  EXPECT_EQ(static_cast<GLenum>(12), cmd.precisiontype);
1182  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_id);
1183  EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_offset);
1184  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1185}
1186
1187TEST_F(GLES2FormatTest, GetShaderSource) {
1188  cmds::GetShaderSource& cmd = *GetBufferAs<cmds::GetShaderSource>();
1189  void* next_cmd =
1190      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
1191  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderSource::kCmdId),
1192            cmd.header.command);
1193  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1194  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1195  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1196  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1197}
1198
1199TEST_F(GLES2FormatTest, GetString) {
1200  cmds::GetString& cmd = *GetBufferAs<cmds::GetString>();
1201  void* next_cmd =
1202      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<uint32>(12));
1203  EXPECT_EQ(static_cast<uint32>(cmds::GetString::kCmdId), cmd.header.command);
1204  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1205  EXPECT_EQ(static_cast<GLenum>(11), cmd.name);
1206  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1207  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1208}
1209
1210TEST_F(GLES2FormatTest, GetTexParameterfv) {
1211  cmds::GetTexParameterfv& cmd = *GetBufferAs<cmds::GetTexParameterfv>();
1212  void* next_cmd = cmd.Set(&cmd,
1213                           static_cast<GLenum>(11),
1214                           static_cast<GLenum>(12),
1215                           static_cast<uint32>(13),
1216                           static_cast<uint32>(14));
1217  EXPECT_EQ(static_cast<uint32>(cmds::GetTexParameterfv::kCmdId),
1218            cmd.header.command);
1219  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1220  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1221  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1222  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1223  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1224  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1225}
1226
1227TEST_F(GLES2FormatTest, GetTexParameteriv) {
1228  cmds::GetTexParameteriv& cmd = *GetBufferAs<cmds::GetTexParameteriv>();
1229  void* next_cmd = cmd.Set(&cmd,
1230                           static_cast<GLenum>(11),
1231                           static_cast<GLenum>(12),
1232                           static_cast<uint32>(13),
1233                           static_cast<uint32>(14));
1234  EXPECT_EQ(static_cast<uint32>(cmds::GetTexParameteriv::kCmdId),
1235            cmd.header.command);
1236  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1237  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1238  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1239  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1240  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1241  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1242}
1243
1244TEST_F(GLES2FormatTest, GetUniformfv) {
1245  cmds::GetUniformfv& cmd = *GetBufferAs<cmds::GetUniformfv>();
1246  void* next_cmd = cmd.Set(&cmd,
1247                           static_cast<GLuint>(11),
1248                           static_cast<GLint>(12),
1249                           static_cast<uint32>(13),
1250                           static_cast<uint32>(14));
1251  EXPECT_EQ(static_cast<uint32>(cmds::GetUniformfv::kCmdId),
1252            cmd.header.command);
1253  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1254  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1255  EXPECT_EQ(static_cast<GLint>(12), cmd.location);
1256  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1257  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1258  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1259}
1260
1261TEST_F(GLES2FormatTest, GetUniformiv) {
1262  cmds::GetUniformiv& cmd = *GetBufferAs<cmds::GetUniformiv>();
1263  void* next_cmd = cmd.Set(&cmd,
1264                           static_cast<GLuint>(11),
1265                           static_cast<GLint>(12),
1266                           static_cast<uint32>(13),
1267                           static_cast<uint32>(14));
1268  EXPECT_EQ(static_cast<uint32>(cmds::GetUniformiv::kCmdId),
1269            cmd.header.command);
1270  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1271  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1272  EXPECT_EQ(static_cast<GLint>(12), cmd.location);
1273  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1274  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1275  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1276}
1277
1278// TODO(gman): Write test for GetUniformLocation
1279// TODO(gman): Write test for GetUniformLocationBucket
1280TEST_F(GLES2FormatTest, GetVertexAttribfv) {
1281  cmds::GetVertexAttribfv& cmd = *GetBufferAs<cmds::GetVertexAttribfv>();
1282  void* next_cmd = cmd.Set(&cmd,
1283                           static_cast<GLuint>(11),
1284                           static_cast<GLenum>(12),
1285                           static_cast<uint32>(13),
1286                           static_cast<uint32>(14));
1287  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribfv::kCmdId),
1288            cmd.header.command);
1289  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1290  EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
1291  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1292  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1293  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1294  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1295}
1296
1297TEST_F(GLES2FormatTest, GetVertexAttribiv) {
1298  cmds::GetVertexAttribiv& cmd = *GetBufferAs<cmds::GetVertexAttribiv>();
1299  void* next_cmd = cmd.Set(&cmd,
1300                           static_cast<GLuint>(11),
1301                           static_cast<GLenum>(12),
1302                           static_cast<uint32>(13),
1303                           static_cast<uint32>(14));
1304  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribiv::kCmdId),
1305            cmd.header.command);
1306  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1307  EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
1308  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1309  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1310  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1311  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1312}
1313
1314TEST_F(GLES2FormatTest, GetVertexAttribPointerv) {
1315  cmds::GetVertexAttribPointerv& cmd =
1316      *GetBufferAs<cmds::GetVertexAttribPointerv>();
1317  void* next_cmd = cmd.Set(&cmd,
1318                           static_cast<GLuint>(11),
1319                           static_cast<GLenum>(12),
1320                           static_cast<uint32>(13),
1321                           static_cast<uint32>(14));
1322  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribPointerv::kCmdId),
1323            cmd.header.command);
1324  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1325  EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
1326  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1327  EXPECT_EQ(static_cast<uint32>(13), cmd.pointer_shm_id);
1328  EXPECT_EQ(static_cast<uint32>(14), cmd.pointer_shm_offset);
1329  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1330}
1331
1332TEST_F(GLES2FormatTest, Hint) {
1333  cmds::Hint& cmd = *GetBufferAs<cmds::Hint>();
1334  void* next_cmd =
1335      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
1336  EXPECT_EQ(static_cast<uint32>(cmds::Hint::kCmdId), cmd.header.command);
1337  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1338  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1339  EXPECT_EQ(static_cast<GLenum>(12), cmd.mode);
1340  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1341}
1342
1343TEST_F(GLES2FormatTest, IsBuffer) {
1344  cmds::IsBuffer& cmd = *GetBufferAs<cmds::IsBuffer>();
1345  void* next_cmd = cmd.Set(&cmd,
1346                           static_cast<GLuint>(11),
1347                           static_cast<uint32>(12),
1348                           static_cast<uint32>(13));
1349  EXPECT_EQ(static_cast<uint32>(cmds::IsBuffer::kCmdId), cmd.header.command);
1350  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1351  EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer);
1352  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1353  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1354  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1355}
1356
1357TEST_F(GLES2FormatTest, IsEnabled) {
1358  cmds::IsEnabled& cmd = *GetBufferAs<cmds::IsEnabled>();
1359  void* next_cmd = cmd.Set(&cmd,
1360                           static_cast<GLenum>(11),
1361                           static_cast<uint32>(12),
1362                           static_cast<uint32>(13));
1363  EXPECT_EQ(static_cast<uint32>(cmds::IsEnabled::kCmdId), cmd.header.command);
1364  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1365  EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
1366  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1367  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1368  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1369}
1370
1371TEST_F(GLES2FormatTest, IsFramebuffer) {
1372  cmds::IsFramebuffer& cmd = *GetBufferAs<cmds::IsFramebuffer>();
1373  void* next_cmd = cmd.Set(&cmd,
1374                           static_cast<GLuint>(11),
1375                           static_cast<uint32>(12),
1376                           static_cast<uint32>(13));
1377  EXPECT_EQ(static_cast<uint32>(cmds::IsFramebuffer::kCmdId),
1378            cmd.header.command);
1379  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1380  EXPECT_EQ(static_cast<GLuint>(11), cmd.framebuffer);
1381  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1382  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1383  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1384}
1385
1386TEST_F(GLES2FormatTest, IsProgram) {
1387  cmds::IsProgram& cmd = *GetBufferAs<cmds::IsProgram>();
1388  void* next_cmd = cmd.Set(&cmd,
1389                           static_cast<GLuint>(11),
1390                           static_cast<uint32>(12),
1391                           static_cast<uint32>(13));
1392  EXPECT_EQ(static_cast<uint32>(cmds::IsProgram::kCmdId), cmd.header.command);
1393  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1394  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1395  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1396  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1397  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1398}
1399
1400TEST_F(GLES2FormatTest, IsRenderbuffer) {
1401  cmds::IsRenderbuffer& cmd = *GetBufferAs<cmds::IsRenderbuffer>();
1402  void* next_cmd = cmd.Set(&cmd,
1403                           static_cast<GLuint>(11),
1404                           static_cast<uint32>(12),
1405                           static_cast<uint32>(13));
1406  EXPECT_EQ(static_cast<uint32>(cmds::IsRenderbuffer::kCmdId),
1407            cmd.header.command);
1408  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1409  EXPECT_EQ(static_cast<GLuint>(11), cmd.renderbuffer);
1410  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1411  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1412  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1413}
1414
1415TEST_F(GLES2FormatTest, IsShader) {
1416  cmds::IsShader& cmd = *GetBufferAs<cmds::IsShader>();
1417  void* next_cmd = cmd.Set(&cmd,
1418                           static_cast<GLuint>(11),
1419                           static_cast<uint32>(12),
1420                           static_cast<uint32>(13));
1421  EXPECT_EQ(static_cast<uint32>(cmds::IsShader::kCmdId), cmd.header.command);
1422  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1423  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1424  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1425  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1426  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1427}
1428
1429TEST_F(GLES2FormatTest, IsTexture) {
1430  cmds::IsTexture& cmd = *GetBufferAs<cmds::IsTexture>();
1431  void* next_cmd = cmd.Set(&cmd,
1432                           static_cast<GLuint>(11),
1433                           static_cast<uint32>(12),
1434                           static_cast<uint32>(13));
1435  EXPECT_EQ(static_cast<uint32>(cmds::IsTexture::kCmdId), cmd.header.command);
1436  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1437  EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
1438  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1439  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1440  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1441}
1442
1443TEST_F(GLES2FormatTest, LineWidth) {
1444  cmds::LineWidth& cmd = *GetBufferAs<cmds::LineWidth>();
1445  void* next_cmd = cmd.Set(&cmd, static_cast<GLfloat>(11));
1446  EXPECT_EQ(static_cast<uint32>(cmds::LineWidth::kCmdId), cmd.header.command);
1447  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1448  EXPECT_EQ(static_cast<GLfloat>(11), cmd.width);
1449  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1450}
1451
1452TEST_F(GLES2FormatTest, LinkProgram) {
1453  cmds::LinkProgram& cmd = *GetBufferAs<cmds::LinkProgram>();
1454  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
1455  EXPECT_EQ(static_cast<uint32>(cmds::LinkProgram::kCmdId), cmd.header.command);
1456  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1457  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1458  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1459}
1460
1461TEST_F(GLES2FormatTest, PixelStorei) {
1462  cmds::PixelStorei& cmd = *GetBufferAs<cmds::PixelStorei>();
1463  void* next_cmd =
1464      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12));
1465  EXPECT_EQ(static_cast<uint32>(cmds::PixelStorei::kCmdId), cmd.header.command);
1466  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1467  EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1468  EXPECT_EQ(static_cast<GLint>(12), cmd.param);
1469  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1470}
1471
1472TEST_F(GLES2FormatTest, PolygonOffset) {
1473  cmds::PolygonOffset& cmd = *GetBufferAs<cmds::PolygonOffset>();
1474  void* next_cmd =
1475      cmd.Set(&cmd, static_cast<GLfloat>(11), static_cast<GLfloat>(12));
1476  EXPECT_EQ(static_cast<uint32>(cmds::PolygonOffset::kCmdId),
1477            cmd.header.command);
1478  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1479  EXPECT_EQ(static_cast<GLfloat>(11), cmd.factor);
1480  EXPECT_EQ(static_cast<GLfloat>(12), cmd.units);
1481  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1482}
1483
1484TEST_F(GLES2FormatTest, ReadPixels) {
1485  cmds::ReadPixels& cmd = *GetBufferAs<cmds::ReadPixels>();
1486  void* next_cmd = cmd.Set(&cmd,
1487                           static_cast<GLint>(11),
1488                           static_cast<GLint>(12),
1489                           static_cast<GLsizei>(13),
1490                           static_cast<GLsizei>(14),
1491                           static_cast<GLenum>(15),
1492                           static_cast<GLenum>(16),
1493                           static_cast<uint32>(17),
1494                           static_cast<uint32>(18),
1495                           static_cast<uint32>(19),
1496                           static_cast<uint32>(20),
1497                           static_cast<GLboolean>(21));
1498  EXPECT_EQ(static_cast<uint32>(cmds::ReadPixels::kCmdId), cmd.header.command);
1499  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1500  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
1501  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
1502  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1503  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1504  EXPECT_EQ(static_cast<GLenum>(15), cmd.format);
1505  EXPECT_EQ(static_cast<GLenum>(16), cmd.type);
1506  EXPECT_EQ(static_cast<uint32>(17), cmd.pixels_shm_id);
1507  EXPECT_EQ(static_cast<uint32>(18), cmd.pixels_shm_offset);
1508  EXPECT_EQ(static_cast<uint32>(19), cmd.result_shm_id);
1509  EXPECT_EQ(static_cast<uint32>(20), cmd.result_shm_offset);
1510  EXPECT_EQ(static_cast<GLboolean>(21), cmd.async);
1511  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1512}
1513
1514TEST_F(GLES2FormatTest, ReleaseShaderCompiler) {
1515  cmds::ReleaseShaderCompiler& cmd =
1516      *GetBufferAs<cmds::ReleaseShaderCompiler>();
1517  void* next_cmd = cmd.Set(&cmd);
1518  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseShaderCompiler::kCmdId),
1519            cmd.header.command);
1520  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1521  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1522}
1523
1524TEST_F(GLES2FormatTest, RenderbufferStorage) {
1525  cmds::RenderbufferStorage& cmd = *GetBufferAs<cmds::RenderbufferStorage>();
1526  void* next_cmd = cmd.Set(&cmd,
1527                           static_cast<GLenum>(11),
1528                           static_cast<GLenum>(12),
1529                           static_cast<GLsizei>(13),
1530                           static_cast<GLsizei>(14));
1531  EXPECT_EQ(static_cast<uint32>(cmds::RenderbufferStorage::kCmdId),
1532            cmd.header.command);
1533  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1534  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1535  EXPECT_EQ(static_cast<GLenum>(12), cmd.internalformat);
1536  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1537  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1538  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1539}
1540
1541TEST_F(GLES2FormatTest, SampleCoverage) {
1542  cmds::SampleCoverage& cmd = *GetBufferAs<cmds::SampleCoverage>();
1543  void* next_cmd =
1544      cmd.Set(&cmd, static_cast<GLclampf>(11), static_cast<GLboolean>(12));
1545  EXPECT_EQ(static_cast<uint32>(cmds::SampleCoverage::kCmdId),
1546            cmd.header.command);
1547  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1548  EXPECT_EQ(static_cast<GLclampf>(11), cmd.value);
1549  EXPECT_EQ(static_cast<GLboolean>(12), cmd.invert);
1550  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1551}
1552
1553TEST_F(GLES2FormatTest, Scissor) {
1554  cmds::Scissor& cmd = *GetBufferAs<cmds::Scissor>();
1555  void* next_cmd = cmd.Set(&cmd,
1556                           static_cast<GLint>(11),
1557                           static_cast<GLint>(12),
1558                           static_cast<GLsizei>(13),
1559                           static_cast<GLsizei>(14));
1560  EXPECT_EQ(static_cast<uint32>(cmds::Scissor::kCmdId), cmd.header.command);
1561  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1562  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
1563  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
1564  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1565  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1566  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1567}
1568
1569TEST_F(GLES2FormatTest, ShaderBinary) {
1570  cmds::ShaderBinary& cmd = *GetBufferAs<cmds::ShaderBinary>();
1571  void* next_cmd = cmd.Set(&cmd,
1572                           static_cast<GLsizei>(11),
1573                           static_cast<uint32>(12),
1574                           static_cast<uint32>(13),
1575                           static_cast<GLenum>(14),
1576                           static_cast<uint32>(15),
1577                           static_cast<uint32>(16),
1578                           static_cast<GLsizei>(17));
1579  EXPECT_EQ(static_cast<uint32>(cmds::ShaderBinary::kCmdId),
1580            cmd.header.command);
1581  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1582  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
1583  EXPECT_EQ(static_cast<uint32>(12), cmd.shaders_shm_id);
1584  EXPECT_EQ(static_cast<uint32>(13), cmd.shaders_shm_offset);
1585  EXPECT_EQ(static_cast<GLenum>(14), cmd.binaryformat);
1586  EXPECT_EQ(static_cast<uint32>(15), cmd.binary_shm_id);
1587  EXPECT_EQ(static_cast<uint32>(16), cmd.binary_shm_offset);
1588  EXPECT_EQ(static_cast<GLsizei>(17), cmd.length);
1589  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1590}
1591
1592TEST_F(GLES2FormatTest, ShaderSource) {
1593  cmds::ShaderSource& cmd = *GetBufferAs<cmds::ShaderSource>();
1594  void* next_cmd = cmd.Set(&cmd,
1595                           static_cast<GLuint>(11),
1596                           static_cast<uint32>(12),
1597                           static_cast<uint32>(13),
1598                           static_cast<uint32>(14));
1599  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSource::kCmdId),
1600            cmd.header.command);
1601  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1602  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1603  EXPECT_EQ(static_cast<uint32>(12), cmd.data_shm_id);
1604  EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_offset);
1605  EXPECT_EQ(static_cast<uint32>(14), cmd.data_size);
1606  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1607}
1608
1609TEST_F(GLES2FormatTest, ShaderSourceBucket) {
1610  cmds::ShaderSourceBucket& cmd = *GetBufferAs<cmds::ShaderSourceBucket>();
1611  void* next_cmd =
1612      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
1613  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSourceBucket::kCmdId),
1614            cmd.header.command);
1615  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1616  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1617  EXPECT_EQ(static_cast<uint32>(12), cmd.data_bucket_id);
1618  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1619}
1620
1621TEST_F(GLES2FormatTest, StencilFunc) {
1622  cmds::StencilFunc& cmd = *GetBufferAs<cmds::StencilFunc>();
1623  void* next_cmd = cmd.Set(&cmd,
1624                           static_cast<GLenum>(11),
1625                           static_cast<GLint>(12),
1626                           static_cast<GLuint>(13));
1627  EXPECT_EQ(static_cast<uint32>(cmds::StencilFunc::kCmdId), cmd.header.command);
1628  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1629  EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
1630  EXPECT_EQ(static_cast<GLint>(12), cmd.ref);
1631  EXPECT_EQ(static_cast<GLuint>(13), cmd.mask);
1632  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1633}
1634
1635TEST_F(GLES2FormatTest, StencilFuncSeparate) {
1636  cmds::StencilFuncSeparate& cmd = *GetBufferAs<cmds::StencilFuncSeparate>();
1637  void* next_cmd = cmd.Set(&cmd,
1638                           static_cast<GLenum>(11),
1639                           static_cast<GLenum>(12),
1640                           static_cast<GLint>(13),
1641                           static_cast<GLuint>(14));
1642  EXPECT_EQ(static_cast<uint32>(cmds::StencilFuncSeparate::kCmdId),
1643            cmd.header.command);
1644  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1645  EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
1646  EXPECT_EQ(static_cast<GLenum>(12), cmd.func);
1647  EXPECT_EQ(static_cast<GLint>(13), cmd.ref);
1648  EXPECT_EQ(static_cast<GLuint>(14), cmd.mask);
1649  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1650}
1651
1652TEST_F(GLES2FormatTest, StencilMask) {
1653  cmds::StencilMask& cmd = *GetBufferAs<cmds::StencilMask>();
1654  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
1655  EXPECT_EQ(static_cast<uint32>(cmds::StencilMask::kCmdId), cmd.header.command);
1656  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1657  EXPECT_EQ(static_cast<GLuint>(11), cmd.mask);
1658  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1659}
1660
1661TEST_F(GLES2FormatTest, StencilMaskSeparate) {
1662  cmds::StencilMaskSeparate& cmd = *GetBufferAs<cmds::StencilMaskSeparate>();
1663  void* next_cmd =
1664      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
1665  EXPECT_EQ(static_cast<uint32>(cmds::StencilMaskSeparate::kCmdId),
1666            cmd.header.command);
1667  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1668  EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
1669  EXPECT_EQ(static_cast<GLuint>(12), cmd.mask);
1670  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1671}
1672
1673TEST_F(GLES2FormatTest, StencilOp) {
1674  cmds::StencilOp& cmd = *GetBufferAs<cmds::StencilOp>();
1675  void* next_cmd = cmd.Set(&cmd,
1676                           static_cast<GLenum>(11),
1677                           static_cast<GLenum>(12),
1678                           static_cast<GLenum>(13));
1679  EXPECT_EQ(static_cast<uint32>(cmds::StencilOp::kCmdId), cmd.header.command);
1680  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1681  EXPECT_EQ(static_cast<GLenum>(11), cmd.fail);
1682  EXPECT_EQ(static_cast<GLenum>(12), cmd.zfail);
1683  EXPECT_EQ(static_cast<GLenum>(13), cmd.zpass);
1684  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1685}
1686
1687TEST_F(GLES2FormatTest, StencilOpSeparate) {
1688  cmds::StencilOpSeparate& cmd = *GetBufferAs<cmds::StencilOpSeparate>();
1689  void* next_cmd = cmd.Set(&cmd,
1690                           static_cast<GLenum>(11),
1691                           static_cast<GLenum>(12),
1692                           static_cast<GLenum>(13),
1693                           static_cast<GLenum>(14));
1694  EXPECT_EQ(static_cast<uint32>(cmds::StencilOpSeparate::kCmdId),
1695            cmd.header.command);
1696  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1697  EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
1698  EXPECT_EQ(static_cast<GLenum>(12), cmd.fail);
1699  EXPECT_EQ(static_cast<GLenum>(13), cmd.zfail);
1700  EXPECT_EQ(static_cast<GLenum>(14), cmd.zpass);
1701  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1702}
1703
1704TEST_F(GLES2FormatTest, TexImage2D) {
1705  cmds::TexImage2D& cmd = *GetBufferAs<cmds::TexImage2D>();
1706  void* next_cmd = cmd.Set(&cmd,
1707                           static_cast<GLenum>(11),
1708                           static_cast<GLint>(12),
1709                           static_cast<GLint>(13),
1710                           static_cast<GLsizei>(14),
1711                           static_cast<GLsizei>(15),
1712                           static_cast<GLint>(16),
1713                           static_cast<GLenum>(17),
1714                           static_cast<GLenum>(18),
1715                           static_cast<uint32>(19),
1716                           static_cast<uint32>(20));
1717  EXPECT_EQ(static_cast<uint32>(cmds::TexImage2D::kCmdId), cmd.header.command);
1718  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1719  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1720  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
1721  EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
1722  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
1723  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
1724  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
1725  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
1726  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
1727  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
1728  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
1729  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1730}
1731
1732TEST_F(GLES2FormatTest, TexParameterf) {
1733  cmds::TexParameterf& cmd = *GetBufferAs<cmds::TexParameterf>();
1734  void* next_cmd = cmd.Set(&cmd,
1735                           static_cast<GLenum>(11),
1736                           static_cast<GLenum>(12),
1737                           static_cast<GLfloat>(13));
1738  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterf::kCmdId),
1739            cmd.header.command);
1740  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1741  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1742  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1743  EXPECT_EQ(static_cast<GLfloat>(13), cmd.param);
1744  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1745}
1746
1747TEST_F(GLES2FormatTest, TexParameterfv) {
1748  cmds::TexParameterfv& cmd = *GetBufferAs<cmds::TexParameterfv>();
1749  void* next_cmd = cmd.Set(&cmd,
1750                           static_cast<GLenum>(11),
1751                           static_cast<GLenum>(12),
1752                           static_cast<uint32>(13),
1753                           static_cast<uint32>(14));
1754  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfv::kCmdId),
1755            cmd.header.command);
1756  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1757  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1758  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1759  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1760  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1761  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1762}
1763
1764TEST_F(GLES2FormatTest, TexParameterfvImmediate) {
1765  const int kSomeBaseValueToTestWith = 51;
1766  static GLfloat data[] = {
1767      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), };
1768  cmds::TexParameterfvImmediate& cmd =
1769      *GetBufferAs<cmds::TexParameterfvImmediate>();
1770  void* next_cmd =
1771      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12), data);
1772  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfvImmediate::kCmdId),
1773            cmd.header.command);
1774  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
1775            cmd.header.size * 4u);
1776  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1777  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1778  CheckBytesWrittenMatchesExpectedSize(
1779      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
1780  // TODO(gman): Check that data was inserted;
1781}
1782
1783TEST_F(GLES2FormatTest, TexParameteri) {
1784  cmds::TexParameteri& cmd = *GetBufferAs<cmds::TexParameteri>();
1785  void* next_cmd = cmd.Set(&cmd,
1786                           static_cast<GLenum>(11),
1787                           static_cast<GLenum>(12),
1788                           static_cast<GLint>(13));
1789  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteri::kCmdId),
1790            cmd.header.command);
1791  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1792  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1793  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1794  EXPECT_EQ(static_cast<GLint>(13), cmd.param);
1795  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1796}
1797
1798TEST_F(GLES2FormatTest, TexParameteriv) {
1799  cmds::TexParameteriv& cmd = *GetBufferAs<cmds::TexParameteriv>();
1800  void* next_cmd = cmd.Set(&cmd,
1801                           static_cast<GLenum>(11),
1802                           static_cast<GLenum>(12),
1803                           static_cast<uint32>(13),
1804                           static_cast<uint32>(14));
1805  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteriv::kCmdId),
1806            cmd.header.command);
1807  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1808  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1809  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1810  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1811  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1812  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1813}
1814
1815TEST_F(GLES2FormatTest, TexParameterivImmediate) {
1816  const int kSomeBaseValueToTestWith = 51;
1817  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0), };
1818  cmds::TexParameterivImmediate& cmd =
1819      *GetBufferAs<cmds::TexParameterivImmediate>();
1820  void* next_cmd =
1821      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12), data);
1822  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterivImmediate::kCmdId),
1823            cmd.header.command);
1824  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
1825            cmd.header.size * 4u);
1826  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1827  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1828  CheckBytesWrittenMatchesExpectedSize(
1829      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
1830  // TODO(gman): Check that data was inserted;
1831}
1832
1833TEST_F(GLES2FormatTest, TexSubImage2D) {
1834  cmds::TexSubImage2D& cmd = *GetBufferAs<cmds::TexSubImage2D>();
1835  void* next_cmd = cmd.Set(&cmd,
1836                           static_cast<GLenum>(11),
1837                           static_cast<GLint>(12),
1838                           static_cast<GLint>(13),
1839                           static_cast<GLint>(14),
1840                           static_cast<GLsizei>(15),
1841                           static_cast<GLsizei>(16),
1842                           static_cast<GLenum>(17),
1843                           static_cast<GLenum>(18),
1844                           static_cast<uint32>(19),
1845                           static_cast<uint32>(20),
1846                           static_cast<GLboolean>(21));
1847  EXPECT_EQ(static_cast<uint32>(cmds::TexSubImage2D::kCmdId),
1848            cmd.header.command);
1849  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1850  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1851  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
1852  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
1853  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
1854  EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
1855  EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
1856  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
1857  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
1858  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
1859  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
1860  EXPECT_EQ(static_cast<GLboolean>(21), cmd.internal);
1861  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1862}
1863
1864TEST_F(GLES2FormatTest, Uniform1f) {
1865  cmds::Uniform1f& cmd = *GetBufferAs<cmds::Uniform1f>();
1866  void* next_cmd =
1867      cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLfloat>(12));
1868  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1f::kCmdId), cmd.header.command);
1869  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1870  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
1871  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
1872  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1873}
1874
1875TEST_F(GLES2FormatTest, Uniform1fv) {
1876  cmds::Uniform1fv& cmd = *GetBufferAs<cmds::Uniform1fv>();
1877  void* next_cmd = cmd.Set(&cmd,
1878                           static_cast<GLint>(11),
1879                           static_cast<GLsizei>(12),
1880                           static_cast<uint32>(13),
1881                           static_cast<uint32>(14));
1882  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fv::kCmdId), cmd.header.command);
1883  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1884  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
1885  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
1886  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
1887  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
1888  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1889}
1890
1891TEST_F(GLES2FormatTest, Uniform1fvImmediate) {
1892  const int kSomeBaseValueToTestWith = 51;
1893  static GLfloat data[] = {
1894      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
1895      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), };
1896  cmds::Uniform1fvImmediate& cmd = *GetBufferAs<cmds::Uniform1fvImmediate>();
1897  const GLsizei kNumElements = 2;
1898  const size_t kExpectedCmdSize =
1899      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 1;
1900  void* next_cmd =
1901      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
1902  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fvImmediate::kCmdId),
1903            cmd.header.command);
1904  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
1905  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
1906  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
1907  CheckBytesWrittenMatchesExpectedSize(
1908      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
1909  // TODO(gman): Check that data was inserted;
1910}
1911
1912TEST_F(GLES2FormatTest, Uniform1i) {
1913  cmds::Uniform1i& cmd = *GetBufferAs<cmds::Uniform1i>();
1914  void* next_cmd =
1915      cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12));
1916  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1i::kCmdId), cmd.header.command);
1917  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1918  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
1919  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
1920  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1921}
1922
1923TEST_F(GLES2FormatTest, Uniform1iv) {
1924  cmds::Uniform1iv& cmd = *GetBufferAs<cmds::Uniform1iv>();
1925  void* next_cmd = cmd.Set(&cmd,
1926                           static_cast<GLint>(11),
1927                           static_cast<GLsizei>(12),
1928                           static_cast<uint32>(13),
1929                           static_cast<uint32>(14));
1930  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1iv::kCmdId), cmd.header.command);
1931  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1932  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
1933  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
1934  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
1935  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
1936  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1937}
1938
1939TEST_F(GLES2FormatTest, Uniform1ivImmediate) {
1940  const int kSomeBaseValueToTestWith = 51;
1941  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
1942                         static_cast<GLint>(kSomeBaseValueToTestWith + 1), };
1943  cmds::Uniform1ivImmediate& cmd = *GetBufferAs<cmds::Uniform1ivImmediate>();
1944  const GLsizei kNumElements = 2;
1945  const size_t kExpectedCmdSize =
1946      sizeof(cmd) + kNumElements * sizeof(GLint) * 1;
1947  void* next_cmd =
1948      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
1949  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1ivImmediate::kCmdId),
1950            cmd.header.command);
1951  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
1952  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
1953  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
1954  CheckBytesWrittenMatchesExpectedSize(
1955      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
1956  // TODO(gman): Check that data was inserted;
1957}
1958
1959TEST_F(GLES2FormatTest, Uniform2f) {
1960  cmds::Uniform2f& cmd = *GetBufferAs<cmds::Uniform2f>();
1961  void* next_cmd = cmd.Set(&cmd,
1962                           static_cast<GLint>(11),
1963                           static_cast<GLfloat>(12),
1964                           static_cast<GLfloat>(13));
1965  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2f::kCmdId), cmd.header.command);
1966  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1967  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
1968  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
1969  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
1970  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1971}
1972
1973TEST_F(GLES2FormatTest, Uniform2fv) {
1974  cmds::Uniform2fv& cmd = *GetBufferAs<cmds::Uniform2fv>();
1975  void* next_cmd = cmd.Set(&cmd,
1976                           static_cast<GLint>(11),
1977                           static_cast<GLsizei>(12),
1978                           static_cast<uint32>(13),
1979                           static_cast<uint32>(14));
1980  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fv::kCmdId), cmd.header.command);
1981  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1982  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
1983  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
1984  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
1985  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
1986  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
1987}
1988
1989TEST_F(GLES2FormatTest, Uniform2fvImmediate) {
1990  const int kSomeBaseValueToTestWith = 51;
1991  static GLfloat data[] = {
1992      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
1993      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
1994      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
1995      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), };
1996  cmds::Uniform2fvImmediate& cmd = *GetBufferAs<cmds::Uniform2fvImmediate>();
1997  const GLsizei kNumElements = 2;
1998  const size_t kExpectedCmdSize =
1999      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 2;
2000  void* next_cmd =
2001      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
2002  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fvImmediate::kCmdId),
2003            cmd.header.command);
2004  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2005  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2006  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2007  CheckBytesWrittenMatchesExpectedSize(
2008      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2009  // TODO(gman): Check that data was inserted;
2010}
2011
2012TEST_F(GLES2FormatTest, Uniform2i) {
2013  cmds::Uniform2i& cmd = *GetBufferAs<cmds::Uniform2i>();
2014  void* next_cmd = cmd.Set(&cmd,
2015                           static_cast<GLint>(11),
2016                           static_cast<GLint>(12),
2017                           static_cast<GLint>(13));
2018  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2i::kCmdId), cmd.header.command);
2019  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2020  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2021  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2022  EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2023  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2024}
2025
2026TEST_F(GLES2FormatTest, Uniform2iv) {
2027  cmds::Uniform2iv& cmd = *GetBufferAs<cmds::Uniform2iv>();
2028  void* next_cmd = cmd.Set(&cmd,
2029                           static_cast<GLint>(11),
2030                           static_cast<GLsizei>(12),
2031                           static_cast<uint32>(13),
2032                           static_cast<uint32>(14));
2033  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2iv::kCmdId), cmd.header.command);
2034  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2035  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2036  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2037  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2038  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2039  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2040}
2041
2042TEST_F(GLES2FormatTest, Uniform2ivImmediate) {
2043  const int kSomeBaseValueToTestWith = 51;
2044  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2045                         static_cast<GLint>(kSomeBaseValueToTestWith + 1),
2046                         static_cast<GLint>(kSomeBaseValueToTestWith + 2),
2047                         static_cast<GLint>(kSomeBaseValueToTestWith + 3), };
2048  cmds::Uniform2ivImmediate& cmd = *GetBufferAs<cmds::Uniform2ivImmediate>();
2049  const GLsizei kNumElements = 2;
2050  const size_t kExpectedCmdSize =
2051      sizeof(cmd) + kNumElements * sizeof(GLint) * 2;
2052  void* next_cmd =
2053      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
2054  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2ivImmediate::kCmdId),
2055            cmd.header.command);
2056  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2057  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2058  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2059  CheckBytesWrittenMatchesExpectedSize(
2060      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2061  // TODO(gman): Check that data was inserted;
2062}
2063
2064TEST_F(GLES2FormatTest, Uniform3f) {
2065  cmds::Uniform3f& cmd = *GetBufferAs<cmds::Uniform3f>();
2066  void* next_cmd = cmd.Set(&cmd,
2067                           static_cast<GLint>(11),
2068                           static_cast<GLfloat>(12),
2069                           static_cast<GLfloat>(13),
2070                           static_cast<GLfloat>(14));
2071  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3f::kCmdId), cmd.header.command);
2072  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2073  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2074  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2075  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2076  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2077  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2078}
2079
2080TEST_F(GLES2FormatTest, Uniform3fv) {
2081  cmds::Uniform3fv& cmd = *GetBufferAs<cmds::Uniform3fv>();
2082  void* next_cmd = cmd.Set(&cmd,
2083                           static_cast<GLint>(11),
2084                           static_cast<GLsizei>(12),
2085                           static_cast<uint32>(13),
2086                           static_cast<uint32>(14));
2087  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fv::kCmdId), cmd.header.command);
2088  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2089  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2090  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2091  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2092  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2093  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2094}
2095
2096TEST_F(GLES2FormatTest, Uniform3fvImmediate) {
2097  const int kSomeBaseValueToTestWith = 51;
2098  static GLfloat data[] = {
2099      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2100      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2101      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2102      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2103      static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2104      static_cast<GLfloat>(kSomeBaseValueToTestWith + 5), };
2105  cmds::Uniform3fvImmediate& cmd = *GetBufferAs<cmds::Uniform3fvImmediate>();
2106  const GLsizei kNumElements = 2;
2107  const size_t kExpectedCmdSize =
2108      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 3;
2109  void* next_cmd =
2110      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
2111  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fvImmediate::kCmdId),
2112            cmd.header.command);
2113  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2114  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2115  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2116  CheckBytesWrittenMatchesExpectedSize(
2117      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2118  // TODO(gman): Check that data was inserted;
2119}
2120
2121TEST_F(GLES2FormatTest, Uniform3i) {
2122  cmds::Uniform3i& cmd = *GetBufferAs<cmds::Uniform3i>();
2123  void* next_cmd = cmd.Set(&cmd,
2124                           static_cast<GLint>(11),
2125                           static_cast<GLint>(12),
2126                           static_cast<GLint>(13),
2127                           static_cast<GLint>(14));
2128  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3i::kCmdId), cmd.header.command);
2129  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2130  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2131  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2132  EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2133  EXPECT_EQ(static_cast<GLint>(14), cmd.z);
2134  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2135}
2136
2137TEST_F(GLES2FormatTest, Uniform3iv) {
2138  cmds::Uniform3iv& cmd = *GetBufferAs<cmds::Uniform3iv>();
2139  void* next_cmd = cmd.Set(&cmd,
2140                           static_cast<GLint>(11),
2141                           static_cast<GLsizei>(12),
2142                           static_cast<uint32>(13),
2143                           static_cast<uint32>(14));
2144  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3iv::kCmdId), cmd.header.command);
2145  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2146  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2147  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2148  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2149  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2150  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2151}
2152
2153TEST_F(GLES2FormatTest, Uniform3ivImmediate) {
2154  const int kSomeBaseValueToTestWith = 51;
2155  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2156                         static_cast<GLint>(kSomeBaseValueToTestWith + 1),
2157                         static_cast<GLint>(kSomeBaseValueToTestWith + 2),
2158                         static_cast<GLint>(kSomeBaseValueToTestWith + 3),
2159                         static_cast<GLint>(kSomeBaseValueToTestWith + 4),
2160                         static_cast<GLint>(kSomeBaseValueToTestWith + 5), };
2161  cmds::Uniform3ivImmediate& cmd = *GetBufferAs<cmds::Uniform3ivImmediate>();
2162  const GLsizei kNumElements = 2;
2163  const size_t kExpectedCmdSize =
2164      sizeof(cmd) + kNumElements * sizeof(GLint) * 3;
2165  void* next_cmd =
2166      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
2167  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3ivImmediate::kCmdId),
2168            cmd.header.command);
2169  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2170  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2171  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2172  CheckBytesWrittenMatchesExpectedSize(
2173      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2174  // TODO(gman): Check that data was inserted;
2175}
2176
2177TEST_F(GLES2FormatTest, Uniform4f) {
2178  cmds::Uniform4f& cmd = *GetBufferAs<cmds::Uniform4f>();
2179  void* next_cmd = cmd.Set(&cmd,
2180                           static_cast<GLint>(11),
2181                           static_cast<GLfloat>(12),
2182                           static_cast<GLfloat>(13),
2183                           static_cast<GLfloat>(14),
2184                           static_cast<GLfloat>(15));
2185  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4f::kCmdId), cmd.header.command);
2186  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2187  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2188  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2189  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2190  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2191  EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
2192  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2193}
2194
2195TEST_F(GLES2FormatTest, Uniform4fv) {
2196  cmds::Uniform4fv& cmd = *GetBufferAs<cmds::Uniform4fv>();
2197  void* next_cmd = cmd.Set(&cmd,
2198                           static_cast<GLint>(11),
2199                           static_cast<GLsizei>(12),
2200                           static_cast<uint32>(13),
2201                           static_cast<uint32>(14));
2202  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fv::kCmdId), cmd.header.command);
2203  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2204  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2205  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2206  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2207  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2208  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2209}
2210
2211TEST_F(GLES2FormatTest, Uniform4fvImmediate) {
2212  const int kSomeBaseValueToTestWith = 51;
2213  static GLfloat data[] = {
2214      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2215      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2216      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2217      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2218      static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2219      static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2220      static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2221      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), };
2222  cmds::Uniform4fvImmediate& cmd = *GetBufferAs<cmds::Uniform4fvImmediate>();
2223  const GLsizei kNumElements = 2;
2224  const size_t kExpectedCmdSize =
2225      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
2226  void* next_cmd =
2227      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
2228  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fvImmediate::kCmdId),
2229            cmd.header.command);
2230  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2231  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2232  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2233  CheckBytesWrittenMatchesExpectedSize(
2234      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2235  // TODO(gman): Check that data was inserted;
2236}
2237
2238TEST_F(GLES2FormatTest, Uniform4i) {
2239  cmds::Uniform4i& cmd = *GetBufferAs<cmds::Uniform4i>();
2240  void* next_cmd = cmd.Set(&cmd,
2241                           static_cast<GLint>(11),
2242                           static_cast<GLint>(12),
2243                           static_cast<GLint>(13),
2244                           static_cast<GLint>(14),
2245                           static_cast<GLint>(15));
2246  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4i::kCmdId), cmd.header.command);
2247  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2248  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2249  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2250  EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2251  EXPECT_EQ(static_cast<GLint>(14), cmd.z);
2252  EXPECT_EQ(static_cast<GLint>(15), cmd.w);
2253  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2254}
2255
2256TEST_F(GLES2FormatTest, Uniform4iv) {
2257  cmds::Uniform4iv& cmd = *GetBufferAs<cmds::Uniform4iv>();
2258  void* next_cmd = cmd.Set(&cmd,
2259                           static_cast<GLint>(11),
2260                           static_cast<GLsizei>(12),
2261                           static_cast<uint32>(13),
2262                           static_cast<uint32>(14));
2263  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4iv::kCmdId), cmd.header.command);
2264  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2265  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2266  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2267  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2268  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2269  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2270}
2271
2272TEST_F(GLES2FormatTest, Uniform4ivImmediate) {
2273  const int kSomeBaseValueToTestWith = 51;
2274  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2275                         static_cast<GLint>(kSomeBaseValueToTestWith + 1),
2276                         static_cast<GLint>(kSomeBaseValueToTestWith + 2),
2277                         static_cast<GLint>(kSomeBaseValueToTestWith + 3),
2278                         static_cast<GLint>(kSomeBaseValueToTestWith + 4),
2279                         static_cast<GLint>(kSomeBaseValueToTestWith + 5),
2280                         static_cast<GLint>(kSomeBaseValueToTestWith + 6),
2281                         static_cast<GLint>(kSomeBaseValueToTestWith + 7), };
2282  cmds::Uniform4ivImmediate& cmd = *GetBufferAs<cmds::Uniform4ivImmediate>();
2283  const GLsizei kNumElements = 2;
2284  const size_t kExpectedCmdSize =
2285      sizeof(cmd) + kNumElements * sizeof(GLint) * 4;
2286  void* next_cmd =
2287      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
2288  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4ivImmediate::kCmdId),
2289            cmd.header.command);
2290  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2291  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2292  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2293  CheckBytesWrittenMatchesExpectedSize(
2294      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2295  // TODO(gman): Check that data was inserted;
2296}
2297
2298TEST_F(GLES2FormatTest, UniformMatrix2fv) {
2299  cmds::UniformMatrix2fv& cmd = *GetBufferAs<cmds::UniformMatrix2fv>();
2300  void* next_cmd = cmd.Set(&cmd,
2301                           static_cast<GLint>(11),
2302                           static_cast<GLsizei>(12),
2303                           static_cast<GLboolean>(13),
2304                           static_cast<uint32>(14),
2305                           static_cast<uint32>(15));
2306  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fv::kCmdId),
2307            cmd.header.command);
2308  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2309  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2310  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2311  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2312  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2313  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2314  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2315}
2316
2317TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
2318  const int kSomeBaseValueToTestWith = 51;
2319  static GLfloat data[] = {
2320      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2321      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2322      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2323      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2324      static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2325      static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2326      static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2327      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), };
2328  cmds::UniformMatrix2fvImmediate& cmd =
2329      *GetBufferAs<cmds::UniformMatrix2fvImmediate>();
2330  const GLsizei kNumElements = 2;
2331  const size_t kExpectedCmdSize =
2332      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
2333  void* next_cmd = cmd.Set(&cmd,
2334                           static_cast<GLint>(1),
2335                           static_cast<GLsizei>(2),
2336                           static_cast<GLboolean>(3),
2337                           data);
2338  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fvImmediate::kCmdId),
2339            cmd.header.command);
2340  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2341  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2342  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2343  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2344  CheckBytesWrittenMatchesExpectedSize(
2345      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2346  // TODO(gman): Check that data was inserted;
2347}
2348
2349TEST_F(GLES2FormatTest, UniformMatrix3fv) {
2350  cmds::UniformMatrix3fv& cmd = *GetBufferAs<cmds::UniformMatrix3fv>();
2351  void* next_cmd = cmd.Set(&cmd,
2352                           static_cast<GLint>(11),
2353                           static_cast<GLsizei>(12),
2354                           static_cast<GLboolean>(13),
2355                           static_cast<uint32>(14),
2356                           static_cast<uint32>(15));
2357  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fv::kCmdId),
2358            cmd.header.command);
2359  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2360  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2361  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2362  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2363  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2364  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2365  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2366}
2367
2368TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
2369  const int kSomeBaseValueToTestWith = 51;
2370  static GLfloat data[] = {
2371      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2372      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2373      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2374      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2375      static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2376      static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2377      static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2378      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
2379      static_cast<GLfloat>(kSomeBaseValueToTestWith + 8),
2380      static_cast<GLfloat>(kSomeBaseValueToTestWith + 9),
2381      static_cast<GLfloat>(kSomeBaseValueToTestWith + 10),
2382      static_cast<GLfloat>(kSomeBaseValueToTestWith + 11),
2383      static_cast<GLfloat>(kSomeBaseValueToTestWith + 12),
2384      static_cast<GLfloat>(kSomeBaseValueToTestWith + 13),
2385      static_cast<GLfloat>(kSomeBaseValueToTestWith + 14),
2386      static_cast<GLfloat>(kSomeBaseValueToTestWith + 15),
2387      static_cast<GLfloat>(kSomeBaseValueToTestWith + 16),
2388      static_cast<GLfloat>(kSomeBaseValueToTestWith + 17), };
2389  cmds::UniformMatrix3fvImmediate& cmd =
2390      *GetBufferAs<cmds::UniformMatrix3fvImmediate>();
2391  const GLsizei kNumElements = 2;
2392  const size_t kExpectedCmdSize =
2393      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 9;
2394  void* next_cmd = cmd.Set(&cmd,
2395                           static_cast<GLint>(1),
2396                           static_cast<GLsizei>(2),
2397                           static_cast<GLboolean>(3),
2398                           data);
2399  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fvImmediate::kCmdId),
2400            cmd.header.command);
2401  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2402  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2403  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2404  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2405  CheckBytesWrittenMatchesExpectedSize(
2406      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2407  // TODO(gman): Check that data was inserted;
2408}
2409
2410TEST_F(GLES2FormatTest, UniformMatrix4fv) {
2411  cmds::UniformMatrix4fv& cmd = *GetBufferAs<cmds::UniformMatrix4fv>();
2412  void* next_cmd = cmd.Set(&cmd,
2413                           static_cast<GLint>(11),
2414                           static_cast<GLsizei>(12),
2415                           static_cast<GLboolean>(13),
2416                           static_cast<uint32>(14),
2417                           static_cast<uint32>(15));
2418  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fv::kCmdId),
2419            cmd.header.command);
2420  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2421  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2422  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2423  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2424  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2425  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2426  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2427}
2428
2429TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
2430  const int kSomeBaseValueToTestWith = 51;
2431  static GLfloat data[] = {
2432      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2433      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2434      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2435      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2436      static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2437      static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2438      static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2439      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
2440      static_cast<GLfloat>(kSomeBaseValueToTestWith + 8),
2441      static_cast<GLfloat>(kSomeBaseValueToTestWith + 9),
2442      static_cast<GLfloat>(kSomeBaseValueToTestWith + 10),
2443      static_cast<GLfloat>(kSomeBaseValueToTestWith + 11),
2444      static_cast<GLfloat>(kSomeBaseValueToTestWith + 12),
2445      static_cast<GLfloat>(kSomeBaseValueToTestWith + 13),
2446      static_cast<GLfloat>(kSomeBaseValueToTestWith + 14),
2447      static_cast<GLfloat>(kSomeBaseValueToTestWith + 15),
2448      static_cast<GLfloat>(kSomeBaseValueToTestWith + 16),
2449      static_cast<GLfloat>(kSomeBaseValueToTestWith + 17),
2450      static_cast<GLfloat>(kSomeBaseValueToTestWith + 18),
2451      static_cast<GLfloat>(kSomeBaseValueToTestWith + 19),
2452      static_cast<GLfloat>(kSomeBaseValueToTestWith + 20),
2453      static_cast<GLfloat>(kSomeBaseValueToTestWith + 21),
2454      static_cast<GLfloat>(kSomeBaseValueToTestWith + 22),
2455      static_cast<GLfloat>(kSomeBaseValueToTestWith + 23),
2456      static_cast<GLfloat>(kSomeBaseValueToTestWith + 24),
2457      static_cast<GLfloat>(kSomeBaseValueToTestWith + 25),
2458      static_cast<GLfloat>(kSomeBaseValueToTestWith + 26),
2459      static_cast<GLfloat>(kSomeBaseValueToTestWith + 27),
2460      static_cast<GLfloat>(kSomeBaseValueToTestWith + 28),
2461      static_cast<GLfloat>(kSomeBaseValueToTestWith + 29),
2462      static_cast<GLfloat>(kSomeBaseValueToTestWith + 30),
2463      static_cast<GLfloat>(kSomeBaseValueToTestWith + 31), };
2464  cmds::UniformMatrix4fvImmediate& cmd =
2465      *GetBufferAs<cmds::UniformMatrix4fvImmediate>();
2466  const GLsizei kNumElements = 2;
2467  const size_t kExpectedCmdSize =
2468      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 16;
2469  void* next_cmd = cmd.Set(&cmd,
2470                           static_cast<GLint>(1),
2471                           static_cast<GLsizei>(2),
2472                           static_cast<GLboolean>(3),
2473                           data);
2474  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fvImmediate::kCmdId),
2475            cmd.header.command);
2476  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2477  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2478  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2479  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2480  CheckBytesWrittenMatchesExpectedSize(
2481      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2482  // TODO(gman): Check that data was inserted;
2483}
2484
2485TEST_F(GLES2FormatTest, UseProgram) {
2486  cmds::UseProgram& cmd = *GetBufferAs<cmds::UseProgram>();
2487  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
2488  EXPECT_EQ(static_cast<uint32>(cmds::UseProgram::kCmdId), cmd.header.command);
2489  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2490  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
2491  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2492}
2493
2494TEST_F(GLES2FormatTest, ValidateProgram) {
2495  cmds::ValidateProgram& cmd = *GetBufferAs<cmds::ValidateProgram>();
2496  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
2497  EXPECT_EQ(static_cast<uint32>(cmds::ValidateProgram::kCmdId),
2498            cmd.header.command);
2499  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2500  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
2501  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2502}
2503
2504TEST_F(GLES2FormatTest, VertexAttrib1f) {
2505  cmds::VertexAttrib1f& cmd = *GetBufferAs<cmds::VertexAttrib1f>();
2506  void* next_cmd =
2507      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLfloat>(12));
2508  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1f::kCmdId),
2509            cmd.header.command);
2510  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2511  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2512  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2513  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2514}
2515
2516TEST_F(GLES2FormatTest, VertexAttrib1fv) {
2517  cmds::VertexAttrib1fv& cmd = *GetBufferAs<cmds::VertexAttrib1fv>();
2518  void* next_cmd = cmd.Set(&cmd,
2519                           static_cast<GLuint>(11),
2520                           static_cast<uint32>(12),
2521                           static_cast<uint32>(13));
2522  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fv::kCmdId),
2523            cmd.header.command);
2524  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2525  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2526  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
2527  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
2528  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2529}
2530
2531TEST_F(GLES2FormatTest, VertexAttrib1fvImmediate) {
2532  const int kSomeBaseValueToTestWith = 51;
2533  static GLfloat data[] = {
2534      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), };
2535  cmds::VertexAttrib1fvImmediate& cmd =
2536      *GetBufferAs<cmds::VertexAttrib1fvImmediate>();
2537  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
2538  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fvImmediate::kCmdId),
2539            cmd.header.command);
2540  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
2541            cmd.header.size * 4u);
2542  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2543  CheckBytesWrittenMatchesExpectedSize(
2544      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2545  // TODO(gman): Check that data was inserted;
2546}
2547
2548TEST_F(GLES2FormatTest, VertexAttrib2f) {
2549  cmds::VertexAttrib2f& cmd = *GetBufferAs<cmds::VertexAttrib2f>();
2550  void* next_cmd = cmd.Set(&cmd,
2551                           static_cast<GLuint>(11),
2552                           static_cast<GLfloat>(12),
2553                           static_cast<GLfloat>(13));
2554  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2f::kCmdId),
2555            cmd.header.command);
2556  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2557  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2558  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2559  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2560  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2561}
2562
2563TEST_F(GLES2FormatTest, VertexAttrib2fv) {
2564  cmds::VertexAttrib2fv& cmd = *GetBufferAs<cmds::VertexAttrib2fv>();
2565  void* next_cmd = cmd.Set(&cmd,
2566                           static_cast<GLuint>(11),
2567                           static_cast<uint32>(12),
2568                           static_cast<uint32>(13));
2569  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fv::kCmdId),
2570            cmd.header.command);
2571  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2572  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2573  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
2574  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
2575  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2576}
2577
2578TEST_F(GLES2FormatTest, VertexAttrib2fvImmediate) {
2579  const int kSomeBaseValueToTestWith = 51;
2580  static GLfloat data[] = {
2581      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2582      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), };
2583  cmds::VertexAttrib2fvImmediate& cmd =
2584      *GetBufferAs<cmds::VertexAttrib2fvImmediate>();
2585  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
2586  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fvImmediate::kCmdId),
2587            cmd.header.command);
2588  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
2589            cmd.header.size * 4u);
2590  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2591  CheckBytesWrittenMatchesExpectedSize(
2592      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2593  // TODO(gman): Check that data was inserted;
2594}
2595
2596TEST_F(GLES2FormatTest, VertexAttrib3f) {
2597  cmds::VertexAttrib3f& cmd = *GetBufferAs<cmds::VertexAttrib3f>();
2598  void* next_cmd = cmd.Set(&cmd,
2599                           static_cast<GLuint>(11),
2600                           static_cast<GLfloat>(12),
2601                           static_cast<GLfloat>(13),
2602                           static_cast<GLfloat>(14));
2603  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3f::kCmdId),
2604            cmd.header.command);
2605  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2606  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2607  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2608  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2609  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2610  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2611}
2612
2613TEST_F(GLES2FormatTest, VertexAttrib3fv) {
2614  cmds::VertexAttrib3fv& cmd = *GetBufferAs<cmds::VertexAttrib3fv>();
2615  void* next_cmd = cmd.Set(&cmd,
2616                           static_cast<GLuint>(11),
2617                           static_cast<uint32>(12),
2618                           static_cast<uint32>(13));
2619  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fv::kCmdId),
2620            cmd.header.command);
2621  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2622  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2623  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
2624  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
2625  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2626}
2627
2628TEST_F(GLES2FormatTest, VertexAttrib3fvImmediate) {
2629  const int kSomeBaseValueToTestWith = 51;
2630  static GLfloat data[] = {
2631      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2632      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2633      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), };
2634  cmds::VertexAttrib3fvImmediate& cmd =
2635      *GetBufferAs<cmds::VertexAttrib3fvImmediate>();
2636  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
2637  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fvImmediate::kCmdId),
2638            cmd.header.command);
2639  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
2640            cmd.header.size * 4u);
2641  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2642  CheckBytesWrittenMatchesExpectedSize(
2643      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2644  // TODO(gman): Check that data was inserted;
2645}
2646
2647TEST_F(GLES2FormatTest, VertexAttrib4f) {
2648  cmds::VertexAttrib4f& cmd = *GetBufferAs<cmds::VertexAttrib4f>();
2649  void* next_cmd = cmd.Set(&cmd,
2650                           static_cast<GLuint>(11),
2651                           static_cast<GLfloat>(12),
2652                           static_cast<GLfloat>(13),
2653                           static_cast<GLfloat>(14),
2654                           static_cast<GLfloat>(15));
2655  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4f::kCmdId),
2656            cmd.header.command);
2657  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2658  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2659  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2660  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2661  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2662  EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
2663  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2664}
2665
2666TEST_F(GLES2FormatTest, VertexAttrib4fv) {
2667  cmds::VertexAttrib4fv& cmd = *GetBufferAs<cmds::VertexAttrib4fv>();
2668  void* next_cmd = cmd.Set(&cmd,
2669                           static_cast<GLuint>(11),
2670                           static_cast<uint32>(12),
2671                           static_cast<uint32>(13));
2672  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fv::kCmdId),
2673            cmd.header.command);
2674  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2675  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2676  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
2677  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
2678  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2679}
2680
2681TEST_F(GLES2FormatTest, VertexAttrib4fvImmediate) {
2682  const int kSomeBaseValueToTestWith = 51;
2683  static GLfloat data[] = {
2684      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2685      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2686      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2687      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), };
2688  cmds::VertexAttrib4fvImmediate& cmd =
2689      *GetBufferAs<cmds::VertexAttrib4fvImmediate>();
2690  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
2691  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fvImmediate::kCmdId),
2692            cmd.header.command);
2693  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
2694            cmd.header.size * 4u);
2695  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2696  CheckBytesWrittenMatchesExpectedSize(
2697      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
2698  // TODO(gman): Check that data was inserted;
2699}
2700
2701TEST_F(GLES2FormatTest, VertexAttribPointer) {
2702  cmds::VertexAttribPointer& cmd = *GetBufferAs<cmds::VertexAttribPointer>();
2703  void* next_cmd = cmd.Set(&cmd,
2704                           static_cast<GLuint>(11),
2705                           static_cast<GLint>(12),
2706                           static_cast<GLenum>(13),
2707                           static_cast<GLboolean>(14),
2708                           static_cast<GLsizei>(15),
2709                           static_cast<GLuint>(16));
2710  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribPointer::kCmdId),
2711            cmd.header.command);
2712  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2713  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
2714  EXPECT_EQ(static_cast<GLint>(12), cmd.size);
2715  EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
2716  EXPECT_EQ(static_cast<GLboolean>(14), cmd.normalized);
2717  EXPECT_EQ(static_cast<GLsizei>(15), cmd.stride);
2718  EXPECT_EQ(static_cast<GLuint>(16), cmd.offset);
2719  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2720}
2721
2722TEST_F(GLES2FormatTest, Viewport) {
2723  cmds::Viewport& cmd = *GetBufferAs<cmds::Viewport>();
2724  void* next_cmd = cmd.Set(&cmd,
2725                           static_cast<GLint>(11),
2726                           static_cast<GLint>(12),
2727                           static_cast<GLsizei>(13),
2728                           static_cast<GLsizei>(14));
2729  EXPECT_EQ(static_cast<uint32>(cmds::Viewport::kCmdId), cmd.header.command);
2730  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2731  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
2732  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
2733  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
2734  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
2735  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2736}
2737
2738TEST_F(GLES2FormatTest, BlitFramebufferCHROMIUM) {
2739  cmds::BlitFramebufferCHROMIUM& cmd =
2740      *GetBufferAs<cmds::BlitFramebufferCHROMIUM>();
2741  void* next_cmd = cmd.Set(&cmd,
2742                           static_cast<GLint>(11),
2743                           static_cast<GLint>(12),
2744                           static_cast<GLint>(13),
2745                           static_cast<GLint>(14),
2746                           static_cast<GLint>(15),
2747                           static_cast<GLint>(16),
2748                           static_cast<GLint>(17),
2749                           static_cast<GLint>(18),
2750                           static_cast<GLbitfield>(19),
2751                           static_cast<GLenum>(20));
2752  EXPECT_EQ(static_cast<uint32>(cmds::BlitFramebufferCHROMIUM::kCmdId),
2753            cmd.header.command);
2754  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2755  EXPECT_EQ(static_cast<GLint>(11), cmd.srcX0);
2756  EXPECT_EQ(static_cast<GLint>(12), cmd.srcY0);
2757  EXPECT_EQ(static_cast<GLint>(13), cmd.srcX1);
2758  EXPECT_EQ(static_cast<GLint>(14), cmd.srcY1);
2759  EXPECT_EQ(static_cast<GLint>(15), cmd.dstX0);
2760  EXPECT_EQ(static_cast<GLint>(16), cmd.dstY0);
2761  EXPECT_EQ(static_cast<GLint>(17), cmd.dstX1);
2762  EXPECT_EQ(static_cast<GLint>(18), cmd.dstY1);
2763  EXPECT_EQ(static_cast<GLbitfield>(19), cmd.mask);
2764  EXPECT_EQ(static_cast<GLenum>(20), cmd.filter);
2765  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2766}
2767
2768TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleCHROMIUM) {
2769  cmds::RenderbufferStorageMultisampleCHROMIUM& cmd =
2770      *GetBufferAs<cmds::RenderbufferStorageMultisampleCHROMIUM>();
2771  void* next_cmd = cmd.Set(&cmd,
2772                           static_cast<GLenum>(11),
2773                           static_cast<GLsizei>(12),
2774                           static_cast<GLenum>(13),
2775                           static_cast<GLsizei>(14),
2776                           static_cast<GLsizei>(15));
2777  EXPECT_EQ(
2778      static_cast<uint32>(cmds::RenderbufferStorageMultisampleCHROMIUM::kCmdId),
2779      cmd.header.command);
2780  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2781  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2782  EXPECT_EQ(static_cast<GLsizei>(12), cmd.samples);
2783  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
2784  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
2785  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
2786  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2787}
2788
2789TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
2790  cmds::RenderbufferStorageMultisampleEXT& cmd =
2791      *GetBufferAs<cmds::RenderbufferStorageMultisampleEXT>();
2792  void* next_cmd = cmd.Set(&cmd,
2793                           static_cast<GLenum>(11),
2794                           static_cast<GLsizei>(12),
2795                           static_cast<GLenum>(13),
2796                           static_cast<GLsizei>(14),
2797                           static_cast<GLsizei>(15));
2798  EXPECT_EQ(
2799      static_cast<uint32>(cmds::RenderbufferStorageMultisampleEXT::kCmdId),
2800      cmd.header.command);
2801  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2802  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2803  EXPECT_EQ(static_cast<GLsizei>(12), cmd.samples);
2804  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
2805  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
2806  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
2807  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2808}
2809
2810TEST_F(GLES2FormatTest, FramebufferTexture2DMultisampleEXT) {
2811  cmds::FramebufferTexture2DMultisampleEXT& cmd =
2812      *GetBufferAs<cmds::FramebufferTexture2DMultisampleEXT>();
2813  void* next_cmd = cmd.Set(&cmd,
2814                           static_cast<GLenum>(11),
2815                           static_cast<GLenum>(12),
2816                           static_cast<GLenum>(13),
2817                           static_cast<GLuint>(14),
2818                           static_cast<GLint>(15),
2819                           static_cast<GLsizei>(16));
2820  EXPECT_EQ(
2821      static_cast<uint32>(cmds::FramebufferTexture2DMultisampleEXT::kCmdId),
2822      cmd.header.command);
2823  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2824  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2825  EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
2826  EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
2827  EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
2828  EXPECT_EQ(static_cast<GLint>(15), cmd.level);
2829  EXPECT_EQ(static_cast<GLsizei>(16), cmd.samples);
2830  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2831}
2832
2833TEST_F(GLES2FormatTest, TexStorage2DEXT) {
2834  cmds::TexStorage2DEXT& cmd = *GetBufferAs<cmds::TexStorage2DEXT>();
2835  void* next_cmd = cmd.Set(&cmd,
2836                           static_cast<GLenum>(11),
2837                           static_cast<GLsizei>(12),
2838                           static_cast<GLenum>(13),
2839                           static_cast<GLsizei>(14),
2840                           static_cast<GLsizei>(15));
2841  EXPECT_EQ(static_cast<uint32>(cmds::TexStorage2DEXT::kCmdId),
2842            cmd.header.command);
2843  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2844  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2845  EXPECT_EQ(static_cast<GLsizei>(12), cmd.levels);
2846  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalFormat);
2847  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
2848  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
2849  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2850}
2851
2852TEST_F(GLES2FormatTest, GenQueriesEXT) {
2853  cmds::GenQueriesEXT& cmd = *GetBufferAs<cmds::GenQueriesEXT>();
2854  void* next_cmd = cmd.Set(&cmd,
2855                           static_cast<GLsizei>(11),
2856                           static_cast<uint32>(12),
2857                           static_cast<uint32>(13));
2858  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXT::kCmdId),
2859            cmd.header.command);
2860  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2861  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
2862  EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
2863  EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
2864  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2865}
2866
2867TEST_F(GLES2FormatTest, GenQueriesEXTImmediate) {
2868  static GLuint ids[] = {12, 23, 34, };
2869  cmds::GenQueriesEXTImmediate& cmd =
2870      *GetBufferAs<cmds::GenQueriesEXTImmediate>();
2871  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
2872  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXTImmediate::kCmdId),
2873            cmd.header.command);
2874  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
2875            cmd.header.size * 4u);
2876  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
2877  CheckBytesWrittenMatchesExpectedSize(
2878      next_cmd,
2879      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
2880  // TODO(gman): Check that ids were inserted;
2881}
2882
2883TEST_F(GLES2FormatTest, DeleteQueriesEXT) {
2884  cmds::DeleteQueriesEXT& cmd = *GetBufferAs<cmds::DeleteQueriesEXT>();
2885  void* next_cmd = cmd.Set(&cmd,
2886                           static_cast<GLsizei>(11),
2887                           static_cast<uint32>(12),
2888                           static_cast<uint32>(13));
2889  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXT::kCmdId),
2890            cmd.header.command);
2891  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2892  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
2893  EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
2894  EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
2895  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2896}
2897
2898TEST_F(GLES2FormatTest, DeleteQueriesEXTImmediate) {
2899  static GLuint ids[] = {12, 23, 34, };
2900  cmds::DeleteQueriesEXTImmediate& cmd =
2901      *GetBufferAs<cmds::DeleteQueriesEXTImmediate>();
2902  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
2903  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXTImmediate::kCmdId),
2904            cmd.header.command);
2905  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
2906            cmd.header.size * 4u);
2907  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
2908  CheckBytesWrittenMatchesExpectedSize(
2909      next_cmd,
2910      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
2911  // TODO(gman): Check that ids were inserted;
2912}
2913
2914TEST_F(GLES2FormatTest, BeginQueryEXT) {
2915  cmds::BeginQueryEXT& cmd = *GetBufferAs<cmds::BeginQueryEXT>();
2916  void* next_cmd = cmd.Set(&cmd,
2917                           static_cast<GLenum>(11),
2918                           static_cast<GLuint>(12),
2919                           static_cast<uint32>(13),
2920                           static_cast<uint32>(14));
2921  EXPECT_EQ(static_cast<uint32>(cmds::BeginQueryEXT::kCmdId),
2922            cmd.header.command);
2923  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2924  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2925  EXPECT_EQ(static_cast<GLuint>(12), cmd.id);
2926  EXPECT_EQ(static_cast<uint32>(13), cmd.sync_data_shm_id);
2927  EXPECT_EQ(static_cast<uint32>(14), cmd.sync_data_shm_offset);
2928  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2929}
2930
2931TEST_F(GLES2FormatTest, EndQueryEXT) {
2932  cmds::EndQueryEXT& cmd = *GetBufferAs<cmds::EndQueryEXT>();
2933  void* next_cmd =
2934      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
2935  EXPECT_EQ(static_cast<uint32>(cmds::EndQueryEXT::kCmdId), cmd.header.command);
2936  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2937  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2938  EXPECT_EQ(static_cast<GLuint>(12), cmd.submit_count);
2939  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2940}
2941
2942TEST_F(GLES2FormatTest, InsertEventMarkerEXT) {
2943  cmds::InsertEventMarkerEXT& cmd = *GetBufferAs<cmds::InsertEventMarkerEXT>();
2944  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
2945  EXPECT_EQ(static_cast<uint32>(cmds::InsertEventMarkerEXT::kCmdId),
2946            cmd.header.command);
2947  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2948  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
2949  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2950}
2951
2952TEST_F(GLES2FormatTest, PushGroupMarkerEXT) {
2953  cmds::PushGroupMarkerEXT& cmd = *GetBufferAs<cmds::PushGroupMarkerEXT>();
2954  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
2955  EXPECT_EQ(static_cast<uint32>(cmds::PushGroupMarkerEXT::kCmdId),
2956            cmd.header.command);
2957  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2958  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
2959  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2960}
2961
2962TEST_F(GLES2FormatTest, PopGroupMarkerEXT) {
2963  cmds::PopGroupMarkerEXT& cmd = *GetBufferAs<cmds::PopGroupMarkerEXT>();
2964  void* next_cmd = cmd.Set(&cmd);
2965  EXPECT_EQ(static_cast<uint32>(cmds::PopGroupMarkerEXT::kCmdId),
2966            cmd.header.command);
2967  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2968  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2969}
2970
2971TEST_F(GLES2FormatTest, GenVertexArraysOES) {
2972  cmds::GenVertexArraysOES& cmd = *GetBufferAs<cmds::GenVertexArraysOES>();
2973  void* next_cmd = cmd.Set(&cmd,
2974                           static_cast<GLsizei>(11),
2975                           static_cast<uint32>(12),
2976                           static_cast<uint32>(13));
2977  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOES::kCmdId),
2978            cmd.header.command);
2979  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2980  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
2981  EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
2982  EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
2983  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
2984}
2985
2986TEST_F(GLES2FormatTest, GenVertexArraysOESImmediate) {
2987  static GLuint ids[] = {12, 23, 34, };
2988  cmds::GenVertexArraysOESImmediate& cmd =
2989      *GetBufferAs<cmds::GenVertexArraysOESImmediate>();
2990  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
2991  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOESImmediate::kCmdId),
2992            cmd.header.command);
2993  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
2994            cmd.header.size * 4u);
2995  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
2996  CheckBytesWrittenMatchesExpectedSize(
2997      next_cmd,
2998      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
2999  // TODO(gman): Check that ids were inserted;
3000}
3001
3002TEST_F(GLES2FormatTest, DeleteVertexArraysOES) {
3003  cmds::DeleteVertexArraysOES& cmd =
3004      *GetBufferAs<cmds::DeleteVertexArraysOES>();
3005  void* next_cmd = cmd.Set(&cmd,
3006                           static_cast<GLsizei>(11),
3007                           static_cast<uint32>(12),
3008                           static_cast<uint32>(13));
3009  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOES::kCmdId),
3010            cmd.header.command);
3011  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3012  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3013  EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
3014  EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
3015  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3016}
3017
3018TEST_F(GLES2FormatTest, DeleteVertexArraysOESImmediate) {
3019  static GLuint ids[] = {12, 23, 34, };
3020  cmds::DeleteVertexArraysOESImmediate& cmd =
3021      *GetBufferAs<cmds::DeleteVertexArraysOESImmediate>();
3022  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3023  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOESImmediate::kCmdId),
3024            cmd.header.command);
3025  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
3026            cmd.header.size * 4u);
3027  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3028  CheckBytesWrittenMatchesExpectedSize(
3029      next_cmd,
3030      sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
3031  // TODO(gman): Check that ids were inserted;
3032}
3033
3034TEST_F(GLES2FormatTest, IsVertexArrayOES) {
3035  cmds::IsVertexArrayOES& cmd = *GetBufferAs<cmds::IsVertexArrayOES>();
3036  void* next_cmd = cmd.Set(&cmd,
3037                           static_cast<GLuint>(11),
3038                           static_cast<uint32>(12),
3039                           static_cast<uint32>(13));
3040  EXPECT_EQ(static_cast<uint32>(cmds::IsVertexArrayOES::kCmdId),
3041            cmd.header.command);
3042  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3043  EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
3044  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3045  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3046  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3047}
3048
3049TEST_F(GLES2FormatTest, BindVertexArrayOES) {
3050  cmds::BindVertexArrayOES& cmd = *GetBufferAs<cmds::BindVertexArrayOES>();
3051  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
3052  EXPECT_EQ(static_cast<uint32>(cmds::BindVertexArrayOES::kCmdId),
3053            cmd.header.command);
3054  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3055  EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
3056  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3057}
3058
3059TEST_F(GLES2FormatTest, SwapBuffers) {
3060  cmds::SwapBuffers& cmd = *GetBufferAs<cmds::SwapBuffers>();
3061  void* next_cmd = cmd.Set(&cmd);
3062  EXPECT_EQ(static_cast<uint32>(cmds::SwapBuffers::kCmdId), cmd.header.command);
3063  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3064  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3065}
3066
3067TEST_F(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
3068  cmds::GetMaxValueInBufferCHROMIUM& cmd =
3069      *GetBufferAs<cmds::GetMaxValueInBufferCHROMIUM>();
3070  void* next_cmd = cmd.Set(&cmd,
3071                           static_cast<GLuint>(11),
3072                           static_cast<GLsizei>(12),
3073                           static_cast<GLenum>(13),
3074                           static_cast<GLuint>(14),
3075                           static_cast<uint32>(15),
3076                           static_cast<uint32>(16));
3077  EXPECT_EQ(static_cast<uint32>(cmds::GetMaxValueInBufferCHROMIUM::kCmdId),
3078            cmd.header.command);
3079  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3080  EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer_id);
3081  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
3082  EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3083  EXPECT_EQ(static_cast<GLuint>(14), cmd.offset);
3084  EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_id);
3085  EXPECT_EQ(static_cast<uint32>(16), cmd.result_shm_offset);
3086  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3087}
3088
3089TEST_F(GLES2FormatTest, GenSharedIdsCHROMIUM) {
3090  cmds::GenSharedIdsCHROMIUM& cmd = *GetBufferAs<cmds::GenSharedIdsCHROMIUM>();
3091  void* next_cmd = cmd.Set(&cmd,
3092                           static_cast<GLuint>(11),
3093                           static_cast<GLuint>(12),
3094                           static_cast<GLsizei>(13),
3095                           static_cast<uint32>(14),
3096                           static_cast<uint32>(15));
3097  EXPECT_EQ(static_cast<uint32>(cmds::GenSharedIdsCHROMIUM::kCmdId),
3098            cmd.header.command);
3099  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3100  EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3101  EXPECT_EQ(static_cast<GLuint>(12), cmd.id_offset);
3102  EXPECT_EQ(static_cast<GLsizei>(13), cmd.n);
3103  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_id);
3104  EXPECT_EQ(static_cast<uint32>(15), cmd.ids_shm_offset);
3105  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3106}
3107
3108TEST_F(GLES2FormatTest, DeleteSharedIdsCHROMIUM) {
3109  cmds::DeleteSharedIdsCHROMIUM& cmd =
3110      *GetBufferAs<cmds::DeleteSharedIdsCHROMIUM>();
3111  void* next_cmd = cmd.Set(&cmd,
3112                           static_cast<GLuint>(11),
3113                           static_cast<GLsizei>(12),
3114                           static_cast<uint32>(13),
3115                           static_cast<uint32>(14));
3116  EXPECT_EQ(static_cast<uint32>(cmds::DeleteSharedIdsCHROMIUM::kCmdId),
3117            cmd.header.command);
3118  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3119  EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3120  EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
3121  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
3122  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
3123  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3124}
3125
3126TEST_F(GLES2FormatTest, RegisterSharedIdsCHROMIUM) {
3127  cmds::RegisterSharedIdsCHROMIUM& cmd =
3128      *GetBufferAs<cmds::RegisterSharedIdsCHROMIUM>();
3129  void* next_cmd = cmd.Set(&cmd,
3130                           static_cast<GLuint>(11),
3131                           static_cast<GLsizei>(12),
3132                           static_cast<uint32>(13),
3133                           static_cast<uint32>(14));
3134  EXPECT_EQ(static_cast<uint32>(cmds::RegisterSharedIdsCHROMIUM::kCmdId),
3135            cmd.header.command);
3136  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3137  EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3138  EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
3139  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
3140  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
3141  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3142}
3143
3144TEST_F(GLES2FormatTest, EnableFeatureCHROMIUM) {
3145  cmds::EnableFeatureCHROMIUM& cmd =
3146      *GetBufferAs<cmds::EnableFeatureCHROMIUM>();
3147  void* next_cmd = cmd.Set(&cmd,
3148                           static_cast<GLuint>(11),
3149                           static_cast<uint32>(12),
3150                           static_cast<uint32>(13));
3151  EXPECT_EQ(static_cast<uint32>(cmds::EnableFeatureCHROMIUM::kCmdId),
3152            cmd.header.command);
3153  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3154  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3155  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3156  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3157  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3158}
3159
3160TEST_F(GLES2FormatTest, ResizeCHROMIUM) {
3161  cmds::ResizeCHROMIUM& cmd = *GetBufferAs<cmds::ResizeCHROMIUM>();
3162  void* next_cmd = cmd.Set(&cmd,
3163                           static_cast<GLuint>(11),
3164                           static_cast<GLuint>(12),
3165                           static_cast<GLfloat>(13));
3166  EXPECT_EQ(static_cast<uint32>(cmds::ResizeCHROMIUM::kCmdId),
3167            cmd.header.command);
3168  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3169  EXPECT_EQ(static_cast<GLuint>(11), cmd.width);
3170  EXPECT_EQ(static_cast<GLuint>(12), cmd.height);
3171  EXPECT_EQ(static_cast<GLfloat>(13), cmd.scale_factor);
3172  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3173}
3174
3175TEST_F(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) {
3176  cmds::GetRequestableExtensionsCHROMIUM& cmd =
3177      *GetBufferAs<cmds::GetRequestableExtensionsCHROMIUM>();
3178  void* next_cmd = cmd.Set(&cmd, static_cast<uint32>(11));
3179  EXPECT_EQ(static_cast<uint32>(cmds::GetRequestableExtensionsCHROMIUM::kCmdId),
3180            cmd.header.command);
3181  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3182  EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
3183  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3184}
3185
3186TEST_F(GLES2FormatTest, RequestExtensionCHROMIUM) {
3187  cmds::RequestExtensionCHROMIUM& cmd =
3188      *GetBufferAs<cmds::RequestExtensionCHROMIUM>();
3189  void* next_cmd = cmd.Set(&cmd, static_cast<uint32>(11));
3190  EXPECT_EQ(static_cast<uint32>(cmds::RequestExtensionCHROMIUM::kCmdId),
3191            cmd.header.command);
3192  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3193  EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
3194  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3195}
3196
3197TEST_F(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
3198  cmds::GetMultipleIntegervCHROMIUM& cmd =
3199      *GetBufferAs<cmds::GetMultipleIntegervCHROMIUM>();
3200  void* next_cmd = cmd.Set(&cmd,
3201                           static_cast<uint32>(11),
3202                           static_cast<uint32>(12),
3203                           static_cast<GLuint>(13),
3204                           static_cast<uint32>(14),
3205                           static_cast<uint32>(15),
3206                           static_cast<GLsizeiptr>(16));
3207  EXPECT_EQ(static_cast<uint32>(cmds::GetMultipleIntegervCHROMIUM::kCmdId),
3208            cmd.header.command);
3209  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3210  EXPECT_EQ(static_cast<uint32>(11), cmd.pnames_shm_id);
3211  EXPECT_EQ(static_cast<uint32>(12), cmd.pnames_shm_offset);
3212  EXPECT_EQ(static_cast<GLuint>(13), cmd.count);
3213  EXPECT_EQ(static_cast<uint32>(14), cmd.results_shm_id);
3214  EXPECT_EQ(static_cast<uint32>(15), cmd.results_shm_offset);
3215  EXPECT_EQ(static_cast<GLsizeiptr>(16), cmd.size);
3216  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3217}
3218
3219TEST_F(GLES2FormatTest, GetProgramInfoCHROMIUM) {
3220  cmds::GetProgramInfoCHROMIUM& cmd =
3221      *GetBufferAs<cmds::GetProgramInfoCHROMIUM>();
3222  void* next_cmd =
3223      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
3224  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramInfoCHROMIUM::kCmdId),
3225            cmd.header.command);
3226  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3227  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
3228  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
3229  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3230}
3231
3232TEST_F(GLES2FormatTest, GetTranslatedShaderSourceANGLE) {
3233  cmds::GetTranslatedShaderSourceANGLE& cmd =
3234      *GetBufferAs<cmds::GetTranslatedShaderSourceANGLE>();
3235  void* next_cmd =
3236      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
3237  EXPECT_EQ(static_cast<uint32>(cmds::GetTranslatedShaderSourceANGLE::kCmdId),
3238            cmd.header.command);
3239  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3240  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
3241  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
3242  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3243}
3244
3245TEST_F(GLES2FormatTest, PostSubBufferCHROMIUM) {
3246  cmds::PostSubBufferCHROMIUM& cmd =
3247      *GetBufferAs<cmds::PostSubBufferCHROMIUM>();
3248  void* next_cmd = cmd.Set(&cmd,
3249                           static_cast<GLint>(11),
3250                           static_cast<GLint>(12),
3251                           static_cast<GLint>(13),
3252                           static_cast<GLint>(14));
3253  EXPECT_EQ(static_cast<uint32>(cmds::PostSubBufferCHROMIUM::kCmdId),
3254            cmd.header.command);
3255  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3256  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
3257  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
3258  EXPECT_EQ(static_cast<GLint>(13), cmd.width);
3259  EXPECT_EQ(static_cast<GLint>(14), cmd.height);
3260  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3261}
3262
3263TEST_F(GLES2FormatTest, TexImageIOSurface2DCHROMIUM) {
3264  cmds::TexImageIOSurface2DCHROMIUM& cmd =
3265      *GetBufferAs<cmds::TexImageIOSurface2DCHROMIUM>();
3266  void* next_cmd = cmd.Set(&cmd,
3267                           static_cast<GLenum>(11),
3268                           static_cast<GLsizei>(12),
3269                           static_cast<GLsizei>(13),
3270                           static_cast<GLuint>(14),
3271                           static_cast<GLuint>(15));
3272  EXPECT_EQ(static_cast<uint32>(cmds::TexImageIOSurface2DCHROMIUM::kCmdId),
3273            cmd.header.command);
3274  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3275  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3276  EXPECT_EQ(static_cast<GLsizei>(12), cmd.width);
3277  EXPECT_EQ(static_cast<GLsizei>(13), cmd.height);
3278  EXPECT_EQ(static_cast<GLuint>(14), cmd.ioSurfaceId);
3279  EXPECT_EQ(static_cast<GLuint>(15), cmd.plane);
3280  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3281}
3282
3283TEST_F(GLES2FormatTest, CopyTextureCHROMIUM) {
3284  cmds::CopyTextureCHROMIUM& cmd = *GetBufferAs<cmds::CopyTextureCHROMIUM>();
3285  void* next_cmd = cmd.Set(&cmd,
3286                           static_cast<GLenum>(11),
3287                           static_cast<GLenum>(12),
3288                           static_cast<GLenum>(13),
3289                           static_cast<GLint>(14),
3290                           static_cast<GLint>(15),
3291                           static_cast<GLenum>(16));
3292  EXPECT_EQ(static_cast<uint32>(cmds::CopyTextureCHROMIUM::kCmdId),
3293            cmd.header.command);
3294  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3295  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3296  EXPECT_EQ(static_cast<GLenum>(12), cmd.source_id);
3297  EXPECT_EQ(static_cast<GLenum>(13), cmd.dest_id);
3298  EXPECT_EQ(static_cast<GLint>(14), cmd.level);
3299  EXPECT_EQ(static_cast<GLint>(15), cmd.internalformat);
3300  EXPECT_EQ(static_cast<GLenum>(16), cmd.dest_type);
3301  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3302}
3303
3304TEST_F(GLES2FormatTest, DrawArraysInstancedANGLE) {
3305  cmds::DrawArraysInstancedANGLE& cmd =
3306      *GetBufferAs<cmds::DrawArraysInstancedANGLE>();
3307  void* next_cmd = cmd.Set(&cmd,
3308                           static_cast<GLenum>(11),
3309                           static_cast<GLint>(12),
3310                           static_cast<GLsizei>(13),
3311                           static_cast<GLsizei>(14));
3312  EXPECT_EQ(static_cast<uint32>(cmds::DrawArraysInstancedANGLE::kCmdId),
3313            cmd.header.command);
3314  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3315  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
3316  EXPECT_EQ(static_cast<GLint>(12), cmd.first);
3317  EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
3318  EXPECT_EQ(static_cast<GLsizei>(14), cmd.primcount);
3319  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3320}
3321
3322TEST_F(GLES2FormatTest, DrawElementsInstancedANGLE) {
3323  cmds::DrawElementsInstancedANGLE& cmd =
3324      *GetBufferAs<cmds::DrawElementsInstancedANGLE>();
3325  void* next_cmd = cmd.Set(&cmd,
3326                           static_cast<GLenum>(11),
3327                           static_cast<GLsizei>(12),
3328                           static_cast<GLenum>(13),
3329                           static_cast<GLuint>(14),
3330                           static_cast<GLsizei>(15));
3331  EXPECT_EQ(static_cast<uint32>(cmds::DrawElementsInstancedANGLE::kCmdId),
3332            cmd.header.command);
3333  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3334  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
3335  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
3336  EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3337  EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
3338  EXPECT_EQ(static_cast<GLsizei>(15), cmd.primcount);
3339  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3340}
3341
3342TEST_F(GLES2FormatTest, VertexAttribDivisorANGLE) {
3343  cmds::VertexAttribDivisorANGLE& cmd =
3344      *GetBufferAs<cmds::VertexAttribDivisorANGLE>();
3345  void* next_cmd =
3346      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12));
3347  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribDivisorANGLE::kCmdId),
3348            cmd.header.command);
3349  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3350  EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
3351  EXPECT_EQ(static_cast<GLuint>(12), cmd.divisor);
3352  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3353}
3354
3355// TODO(gman): Write test for GenMailboxCHROMIUM
3356TEST_F(GLES2FormatTest, ProduceTextureCHROMIUM) {
3357  cmds::ProduceTextureCHROMIUM& cmd =
3358      *GetBufferAs<cmds::ProduceTextureCHROMIUM>();
3359  void* next_cmd = cmd.Set(&cmd,
3360                           static_cast<GLenum>(11),
3361                           static_cast<uint32>(12),
3362                           static_cast<uint32>(13));
3363  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUM::kCmdId),
3364            cmd.header.command);
3365  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3366  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3367  EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
3368  EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
3369  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3370}
3371
3372TEST_F(GLES2FormatTest, ProduceTextureCHROMIUMImmediate) {
3373  const int kSomeBaseValueToTestWith = 51;
3374  static GLbyte data[] = {static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
3375                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
3376                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
3377                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
3378                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
3379                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
3380                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
3381                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
3382                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
3383                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
3384                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
3385                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
3386                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
3387                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
3388                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
3389                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
3390                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
3391                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
3392                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
3393                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
3394                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
3395                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
3396                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
3397                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
3398                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
3399                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
3400                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
3401                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
3402                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
3403                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
3404                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
3405                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
3406                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
3407                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
3408                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
3409                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
3410                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
3411                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
3412                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
3413                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
3414                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
3415                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
3416                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
3417                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
3418                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
3419                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
3420                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
3421                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
3422                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
3423                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
3424                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
3425                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
3426                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
3427                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
3428                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
3429                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
3430                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
3431                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
3432                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
3433                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
3434                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
3435                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
3436                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
3437                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 63), };
3438  cmds::ProduceTextureCHROMIUMImmediate& cmd =
3439      *GetBufferAs<cmds::ProduceTextureCHROMIUMImmediate>();
3440  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11), data);
3441  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUMImmediate::kCmdId),
3442            cmd.header.command);
3443  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
3444            cmd.header.size * 4u);
3445  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3446  CheckBytesWrittenMatchesExpectedSize(
3447      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
3448  // TODO(gman): Check that data was inserted;
3449}
3450
3451TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUM) {
3452  cmds::ConsumeTextureCHROMIUM& cmd =
3453      *GetBufferAs<cmds::ConsumeTextureCHROMIUM>();
3454  void* next_cmd = cmd.Set(&cmd,
3455                           static_cast<GLenum>(11),
3456                           static_cast<uint32>(12),
3457                           static_cast<uint32>(13));
3458  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUM::kCmdId),
3459            cmd.header.command);
3460  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3461  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3462  EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
3463  EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
3464  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3465}
3466
3467TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUMImmediate) {
3468  const int kSomeBaseValueToTestWith = 51;
3469  static GLbyte data[] = {static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
3470                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
3471                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
3472                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
3473                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
3474                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
3475                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
3476                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
3477                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
3478                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
3479                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
3480                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
3481                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
3482                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
3483                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
3484                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
3485                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
3486                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
3487                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
3488                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
3489                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
3490                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
3491                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
3492                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
3493                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
3494                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
3495                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
3496                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
3497                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
3498                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
3499                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
3500                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
3501                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
3502                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
3503                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
3504                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
3505                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
3506                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
3507                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
3508                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
3509                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
3510                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
3511                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
3512                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
3513                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
3514                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
3515                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
3516                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
3517                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
3518                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
3519                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
3520                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
3521                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
3522                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
3523                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
3524                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
3525                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
3526                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
3527                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
3528                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
3529                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
3530                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
3531                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
3532                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 63), };
3533  cmds::ConsumeTextureCHROMIUMImmediate& cmd =
3534      *GetBufferAs<cmds::ConsumeTextureCHROMIUMImmediate>();
3535  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11), data);
3536  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUMImmediate::kCmdId),
3537            cmd.header.command);
3538  EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
3539            cmd.header.size * 4u);
3540  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3541  CheckBytesWrittenMatchesExpectedSize(
3542      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
3543  // TODO(gman): Check that data was inserted;
3544}
3545
3546TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUM) {
3547  cmds::BindUniformLocationCHROMIUM& cmd =
3548      *GetBufferAs<cmds::BindUniformLocationCHROMIUM>();
3549  void* next_cmd = cmd.Set(&cmd,
3550                           static_cast<GLuint>(11),
3551                           static_cast<GLint>(12),
3552                           static_cast<uint32>(13),
3553                           static_cast<uint32>(14),
3554                           static_cast<uint32>(15));
3555  EXPECT_EQ(static_cast<uint32>(cmds::BindUniformLocationCHROMIUM::kCmdId),
3556            cmd.header.command);
3557  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3558  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
3559  EXPECT_EQ(static_cast<GLint>(12), cmd.location);
3560  EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
3561  EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
3562  EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
3563  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3564}
3565
3566TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUMBucket) {
3567  cmds::BindUniformLocationCHROMIUMBucket& cmd =
3568      *GetBufferAs<cmds::BindUniformLocationCHROMIUMBucket>();
3569  void* next_cmd = cmd.Set(&cmd,
3570                           static_cast<GLuint>(11),
3571                           static_cast<GLint>(12),
3572                           static_cast<uint32>(13));
3573  EXPECT_EQ(
3574      static_cast<uint32>(cmds::BindUniformLocationCHROMIUMBucket::kCmdId),
3575      cmd.header.command);
3576  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3577  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
3578  EXPECT_EQ(static_cast<GLint>(12), cmd.location);
3579  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
3580  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3581}
3582
3583TEST_F(GLES2FormatTest, BindTexImage2DCHROMIUM) {
3584  cmds::BindTexImage2DCHROMIUM& cmd =
3585      *GetBufferAs<cmds::BindTexImage2DCHROMIUM>();
3586  void* next_cmd =
3587      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12));
3588  EXPECT_EQ(static_cast<uint32>(cmds::BindTexImage2DCHROMIUM::kCmdId),
3589            cmd.header.command);
3590  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3591  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3592  EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
3593  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3594}
3595
3596TEST_F(GLES2FormatTest, ReleaseTexImage2DCHROMIUM) {
3597  cmds::ReleaseTexImage2DCHROMIUM& cmd =
3598      *GetBufferAs<cmds::ReleaseTexImage2DCHROMIUM>();
3599  void* next_cmd =
3600      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12));
3601  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseTexImage2DCHROMIUM::kCmdId),
3602            cmd.header.command);
3603  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3604  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3605  EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
3606  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3607}
3608
3609TEST_F(GLES2FormatTest, TraceBeginCHROMIUM) {
3610  cmds::TraceBeginCHROMIUM& cmd = *GetBufferAs<cmds::TraceBeginCHROMIUM>();
3611  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
3612  EXPECT_EQ(static_cast<uint32>(cmds::TraceBeginCHROMIUM::kCmdId),
3613            cmd.header.command);
3614  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3615  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3616  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3617}
3618
3619TEST_F(GLES2FormatTest, TraceEndCHROMIUM) {
3620  cmds::TraceEndCHROMIUM& cmd = *GetBufferAs<cmds::TraceEndCHROMIUM>();
3621  void* next_cmd = cmd.Set(&cmd);
3622  EXPECT_EQ(static_cast<uint32>(cmds::TraceEndCHROMIUM::kCmdId),
3623            cmd.header.command);
3624  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3625  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3626}
3627
3628TEST_F(GLES2FormatTest, AsyncTexSubImage2DCHROMIUM) {
3629  cmds::AsyncTexSubImage2DCHROMIUM& cmd =
3630      *GetBufferAs<cmds::AsyncTexSubImage2DCHROMIUM>();
3631  void* next_cmd = cmd.Set(&cmd,
3632                           static_cast<GLenum>(11),
3633                           static_cast<GLint>(12),
3634                           static_cast<GLint>(13),
3635                           static_cast<GLint>(14),
3636                           static_cast<GLsizei>(15),
3637                           static_cast<GLsizei>(16),
3638                           static_cast<GLenum>(17),
3639                           static_cast<GLenum>(18),
3640                           static_cast<uint32>(19),
3641                           static_cast<uint32>(20),
3642                           static_cast<uint32>(21),
3643                           static_cast<uint32>(22),
3644                           static_cast<uint32>(23));
3645  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexSubImage2DCHROMIUM::kCmdId),
3646            cmd.header.command);
3647  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3648  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3649  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
3650  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
3651  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
3652  EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
3653  EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
3654  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
3655  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
3656  EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
3657  EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
3658  EXPECT_EQ(static_cast<uint32>(21), cmd.async_upload_token);
3659  EXPECT_EQ(static_cast<uint32>(22), cmd.sync_data_shm_id);
3660  EXPECT_EQ(static_cast<uint32>(23), cmd.sync_data_shm_offset);
3661  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3662}
3663
3664TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
3665  cmds::AsyncTexImage2DCHROMIUM& cmd =
3666      *GetBufferAs<cmds::AsyncTexImage2DCHROMIUM>();
3667  void* next_cmd = cmd.Set(&cmd,
3668                           static_cast<GLenum>(11),
3669                           static_cast<GLint>(12),
3670                           static_cast<GLint>(13),
3671                           static_cast<GLsizei>(14),
3672                           static_cast<GLsizei>(15),
3673                           static_cast<GLint>(16),
3674                           static_cast<GLenum>(17),
3675                           static_cast<GLenum>(18),
3676                           static_cast<uint32>(19),
3677                           static_cast<uint32>(20),
3678                           static_cast<uint32>(21),
3679                           static_cast<uint32>(22),
3680                           static_cast<uint32>(23));
3681  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexImage2DCHROMIUM::kCmdId),
3682            cmd.header.command);
3683  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3684  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3685  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
3686  EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
3687  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
3688  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
3689  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
3690  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
3691  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
3692  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
3693  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
3694  EXPECT_EQ(static_cast<uint32>(21), cmd.async_upload_token);
3695  EXPECT_EQ(static_cast<uint32>(22), cmd.sync_data_shm_id);
3696  EXPECT_EQ(static_cast<uint32>(23), cmd.sync_data_shm_offset);
3697  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3698}
3699
3700TEST_F(GLES2FormatTest, WaitAsyncTexImage2DCHROMIUM) {
3701  cmds::WaitAsyncTexImage2DCHROMIUM& cmd =
3702      *GetBufferAs<cmds::WaitAsyncTexImage2DCHROMIUM>();
3703  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
3704  EXPECT_EQ(static_cast<uint32>(cmds::WaitAsyncTexImage2DCHROMIUM::kCmdId),
3705            cmd.header.command);
3706  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3707  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3708  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3709}
3710
3711TEST_F(GLES2FormatTest, WaitAllAsyncTexImage2DCHROMIUM) {
3712  cmds::WaitAllAsyncTexImage2DCHROMIUM& cmd =
3713      *GetBufferAs<cmds::WaitAllAsyncTexImage2DCHROMIUM>();
3714  void* next_cmd = cmd.Set(&cmd);
3715  EXPECT_EQ(static_cast<uint32>(cmds::WaitAllAsyncTexImage2DCHROMIUM::kCmdId),
3716            cmd.header.command);
3717  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3718  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3719}
3720
3721TEST_F(GLES2FormatTest, DiscardFramebufferEXT) {
3722  cmds::DiscardFramebufferEXT& cmd =
3723      *GetBufferAs<cmds::DiscardFramebufferEXT>();
3724  void* next_cmd = cmd.Set(&cmd,
3725                           static_cast<GLenum>(11),
3726                           static_cast<GLsizei>(12),
3727                           static_cast<uint32>(13),
3728                           static_cast<uint32>(14));
3729  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXT::kCmdId),
3730            cmd.header.command);
3731  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3732  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3733  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
3734  EXPECT_EQ(static_cast<uint32>(13), cmd.attachments_shm_id);
3735  EXPECT_EQ(static_cast<uint32>(14), cmd.attachments_shm_offset);
3736  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3737}
3738
3739TEST_F(GLES2FormatTest, DiscardFramebufferEXTImmediate) {
3740  const int kSomeBaseValueToTestWith = 51;
3741  static GLenum data[] = {static_cast<GLenum>(kSomeBaseValueToTestWith + 0),
3742                          static_cast<GLenum>(kSomeBaseValueToTestWith + 1), };
3743  cmds::DiscardFramebufferEXTImmediate& cmd =
3744      *GetBufferAs<cmds::DiscardFramebufferEXTImmediate>();
3745  const GLsizei kNumElements = 2;
3746  const size_t kExpectedCmdSize =
3747      sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
3748  void* next_cmd =
3749      cmd.Set(&cmd, static_cast<GLenum>(1), static_cast<GLsizei>(2), data);
3750  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXTImmediate::kCmdId),
3751            cmd.header.command);
3752  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
3753  EXPECT_EQ(static_cast<GLenum>(1), cmd.target);
3754  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
3755  CheckBytesWrittenMatchesExpectedSize(
3756      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
3757  // TODO(gman): Check that data was inserted;
3758}
3759
3760TEST_F(GLES2FormatTest, LoseContextCHROMIUM) {
3761  cmds::LoseContextCHROMIUM& cmd = *GetBufferAs<cmds::LoseContextCHROMIUM>();
3762  void* next_cmd =
3763      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
3764  EXPECT_EQ(static_cast<uint32>(cmds::LoseContextCHROMIUM::kCmdId),
3765            cmd.header.command);
3766  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3767  EXPECT_EQ(static_cast<GLenum>(11), cmd.current);
3768  EXPECT_EQ(static_cast<GLenum>(12), cmd.other);
3769  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3770}
3771
3772// TODO(gman): Write test for InsertSyncPointCHROMIUM
3773TEST_F(GLES2FormatTest, WaitSyncPointCHROMIUM) {
3774  cmds::WaitSyncPointCHROMIUM& cmd =
3775      *GetBufferAs<cmds::WaitSyncPointCHROMIUM>();
3776  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
3777  EXPECT_EQ(static_cast<uint32>(cmds::WaitSyncPointCHROMIUM::kCmdId),
3778            cmd.header.command);
3779  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3780  EXPECT_EQ(static_cast<GLuint>(11), cmd.sync_point);
3781  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3782}
3783
3784TEST_F(GLES2FormatTest, DrawBuffersEXT) {
3785  cmds::DrawBuffersEXT& cmd = *GetBufferAs<cmds::DrawBuffersEXT>();
3786  void* next_cmd = cmd.Set(&cmd,
3787                           static_cast<GLsizei>(11),
3788                           static_cast<uint32>(12),
3789                           static_cast<uint32>(13));
3790  EXPECT_EQ(static_cast<uint32>(cmds::DrawBuffersEXT::kCmdId),
3791            cmd.header.command);
3792  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3793  EXPECT_EQ(static_cast<GLsizei>(11), cmd.count);
3794  EXPECT_EQ(static_cast<uint32>(12), cmd.bufs_shm_id);
3795  EXPECT_EQ(static_cast<uint32>(13), cmd.bufs_shm_offset);
3796  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3797}
3798
3799TEST_F(GLES2FormatTest, DrawBuffersEXTImmediate) {
3800  const int kSomeBaseValueToTestWith = 51;
3801  static GLenum data[] = {static_cast<GLenum>(kSomeBaseValueToTestWith + 0), };
3802  cmds::DrawBuffersEXTImmediate& cmd =
3803      *GetBufferAs<cmds::DrawBuffersEXTImmediate>();
3804  const GLsizei kNumElements = 1;
3805  const size_t kExpectedCmdSize =
3806      sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
3807  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(1), data);
3808  EXPECT_EQ(static_cast<uint32>(cmds::DrawBuffersEXTImmediate::kCmdId),
3809            cmd.header.command);
3810  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
3811  EXPECT_EQ(static_cast<GLsizei>(1), cmd.count);
3812  CheckBytesWrittenMatchesExpectedSize(
3813      next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
3814  // TODO(gman): Check that data was inserted;
3815}
3816
3817TEST_F(GLES2FormatTest, DiscardBackbufferCHROMIUM) {
3818  cmds::DiscardBackbufferCHROMIUM& cmd =
3819      *GetBufferAs<cmds::DiscardBackbufferCHROMIUM>();
3820  void* next_cmd = cmd.Set(&cmd);
3821  EXPECT_EQ(static_cast<uint32>(cmds::DiscardBackbufferCHROMIUM::kCmdId),
3822            cmd.header.command);
3823  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3824  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
3825}
3826
3827#endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
3828