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