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