gles2_cmd_format_test_autogen.h revision 7dbb3d5cf0c15f500944d211057644d6a2f37371 
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  EXPECT_EQ(static_cast<uint32>(cmds::ReadPixels::kCmdId),
1808            cmd.header.command);
1809  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1810  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
1811  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
1812  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1813  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1814  EXPECT_EQ(static_cast<GLenum>(15), cmd.format);
1815  EXPECT_EQ(static_cast<GLenum>(16), cmd.type);
1816  EXPECT_EQ(static_cast<uint32>(17), cmd.pixels_shm_id);
1817  EXPECT_EQ(static_cast<uint32>(18), cmd.pixels_shm_offset);
1818  EXPECT_EQ(static_cast<uint32>(19), cmd.result_shm_id);
1819  EXPECT_EQ(static_cast<uint32>(20), cmd.result_shm_offset);
1820  CheckBytesWrittenMatchesExpectedSize(
1821      next_cmd, sizeof(cmd));
1822}
1823
1824TEST_F(GLES2FormatTest, ReleaseShaderCompiler) {
1825  cmds::ReleaseShaderCompiler& cmd =
1826      *GetBufferAs<cmds::ReleaseShaderCompiler>();
1827  void* next_cmd = cmd.Set(
1828      &cmd);
1829  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseShaderCompiler::kCmdId),
1830            cmd.header.command);
1831  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1832  CheckBytesWrittenMatchesExpectedSize(
1833      next_cmd, sizeof(cmd));
1834}
1835
1836TEST_F(GLES2FormatTest, RenderbufferStorage) {
1837  cmds::RenderbufferStorage& cmd = *GetBufferAs<cmds::RenderbufferStorage>();
1838  void* next_cmd = cmd.Set(
1839      &cmd,
1840      static_cast<GLenum>(11),
1841      static_cast<GLenum>(12),
1842      static_cast<GLsizei>(13),
1843      static_cast<GLsizei>(14));
1844  EXPECT_EQ(static_cast<uint32>(cmds::RenderbufferStorage::kCmdId),
1845            cmd.header.command);
1846  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1847  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1848  EXPECT_EQ(static_cast<GLenum>(12), cmd.internalformat);
1849  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1850  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1851  CheckBytesWrittenMatchesExpectedSize(
1852      next_cmd, sizeof(cmd));
1853}
1854
1855TEST_F(GLES2FormatTest, SampleCoverage) {
1856  cmds::SampleCoverage& cmd = *GetBufferAs<cmds::SampleCoverage>();
1857  void* next_cmd = cmd.Set(
1858      &cmd,
1859      static_cast<GLclampf>(11),
1860      static_cast<GLboolean>(12));
1861  EXPECT_EQ(static_cast<uint32>(cmds::SampleCoverage::kCmdId),
1862            cmd.header.command);
1863  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1864  EXPECT_EQ(static_cast<GLclampf>(11), cmd.value);
1865  EXPECT_EQ(static_cast<GLboolean>(12), cmd.invert);
1866  CheckBytesWrittenMatchesExpectedSize(
1867      next_cmd, sizeof(cmd));
1868}
1869
1870TEST_F(GLES2FormatTest, Scissor) {
1871  cmds::Scissor& cmd = *GetBufferAs<cmds::Scissor>();
1872  void* next_cmd = cmd.Set(
1873      &cmd,
1874      static_cast<GLint>(11),
1875      static_cast<GLint>(12),
1876      static_cast<GLsizei>(13),
1877      static_cast<GLsizei>(14));
1878  EXPECT_EQ(static_cast<uint32>(cmds::Scissor::kCmdId),
1879            cmd.header.command);
1880  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1881  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
1882  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
1883  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1884  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1885  CheckBytesWrittenMatchesExpectedSize(
1886      next_cmd, sizeof(cmd));
1887}
1888
1889TEST_F(GLES2FormatTest, ShaderBinary) {
1890  cmds::ShaderBinary& cmd = *GetBufferAs<cmds::ShaderBinary>();
1891  void* next_cmd = cmd.Set(
1892      &cmd,
1893      static_cast<GLsizei>(11),
1894      static_cast<uint32>(12),
1895      static_cast<uint32>(13),
1896      static_cast<GLenum>(14),
1897      static_cast<uint32>(15),
1898      static_cast<uint32>(16),
1899      static_cast<GLsizei>(17));
1900  EXPECT_EQ(static_cast<uint32>(cmds::ShaderBinary::kCmdId),
1901            cmd.header.command);
1902  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1903  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
1904  EXPECT_EQ(static_cast<uint32>(12), cmd.shaders_shm_id);
1905  EXPECT_EQ(static_cast<uint32>(13), cmd.shaders_shm_offset);
1906  EXPECT_EQ(static_cast<GLenum>(14), cmd.binaryformat);
1907  EXPECT_EQ(static_cast<uint32>(15), cmd.binary_shm_id);
1908  EXPECT_EQ(static_cast<uint32>(16), cmd.binary_shm_offset);
1909  EXPECT_EQ(static_cast<GLsizei>(17), cmd.length);
1910  CheckBytesWrittenMatchesExpectedSize(
1911      next_cmd, sizeof(cmd));
1912}
1913
1914TEST_F(GLES2FormatTest, ShaderSource) {
1915  cmds::ShaderSource& cmd = *GetBufferAs<cmds::ShaderSource>();
1916  void* next_cmd = cmd.Set(
1917      &cmd,
1918      static_cast<GLuint>(11),
1919      static_cast<uint32>(12),
1920      static_cast<uint32>(13),
1921      static_cast<uint32>(14));
1922  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSource::kCmdId),
1923            cmd.header.command);
1924  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1925  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1926  EXPECT_EQ(static_cast<uint32>(12), cmd.data_shm_id);
1927  EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_offset);
1928  EXPECT_EQ(static_cast<uint32>(14), cmd.data_size);
1929  CheckBytesWrittenMatchesExpectedSize(
1930      next_cmd, sizeof(cmd));
1931}
1932
1933// TODO(gman): Implement test for ShaderSourceImmediate
1934TEST_F(GLES2FormatTest, ShaderSourceBucket) {
1935  cmds::ShaderSourceBucket& cmd = *GetBufferAs<cmds::ShaderSourceBucket>();
1936  void* next_cmd = cmd.Set(
1937      &cmd,
1938      static_cast<GLuint>(11),
1939      static_cast<uint32>(12));
1940  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSourceBucket::kCmdId),
1941            cmd.header.command);
1942  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1943  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1944  EXPECT_EQ(static_cast<uint32>(12), cmd.data_bucket_id);
1945  CheckBytesWrittenMatchesExpectedSize(
1946      next_cmd, sizeof(cmd));
1947}
1948
1949TEST_F(GLES2FormatTest, StencilFunc) {
1950  cmds::StencilFunc& cmd = *GetBufferAs<cmds::StencilFunc>();
1951  void* next_cmd = cmd.Set(
1952      &cmd,
1953      static_cast<GLenum>(11),
1954      static_cast<GLint>(12),
1955      static_cast<GLuint>(13));
1956  EXPECT_EQ(static_cast<uint32>(cmds::StencilFunc::kCmdId),
1957            cmd.header.command);
1958  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1959  EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
1960  EXPECT_EQ(static_cast<GLint>(12), cmd.ref);
1961  EXPECT_EQ(static_cast<GLuint>(13), cmd.mask);
1962  CheckBytesWrittenMatchesExpectedSize(
1963      next_cmd, sizeof(cmd));
1964}
1965
1966TEST_F(GLES2FormatTest, StencilFuncSeparate) {
1967  cmds::StencilFuncSeparate& cmd = *GetBufferAs<cmds::StencilFuncSeparate>();
1968  void* next_cmd = cmd.Set(
1969      &cmd,
1970      static_cast<GLenum>(11),
1971      static_cast<GLenum>(12),
1972      static_cast<GLint>(13),
1973      static_cast<GLuint>(14));
1974  EXPECT_EQ(static_cast<uint32>(cmds::StencilFuncSeparate::kCmdId),
1975            cmd.header.command);
1976  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1977  EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
1978  EXPECT_EQ(static_cast<GLenum>(12), cmd.func);
1979  EXPECT_EQ(static_cast<GLint>(13), cmd.ref);
1980  EXPECT_EQ(static_cast<GLuint>(14), cmd.mask);
1981  CheckBytesWrittenMatchesExpectedSize(
1982      next_cmd, sizeof(cmd));
1983}
1984
1985TEST_F(GLES2FormatTest, StencilMask) {
1986  cmds::StencilMask& cmd = *GetBufferAs<cmds::StencilMask>();
1987  void* next_cmd = cmd.Set(
1988      &cmd,
1989      static_cast<GLuint>(11));
1990  EXPECT_EQ(static_cast<uint32>(cmds::StencilMask::kCmdId),
1991            cmd.header.command);
1992  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1993  EXPECT_EQ(static_cast<GLuint>(11), cmd.mask);
1994  CheckBytesWrittenMatchesExpectedSize(
1995      next_cmd, sizeof(cmd));
1996}
1997
1998TEST_F(GLES2FormatTest, StencilMaskSeparate) {
1999  cmds::StencilMaskSeparate& cmd = *GetBufferAs<cmds::StencilMaskSeparate>();
2000  void* next_cmd = cmd.Set(
2001      &cmd,
2002      static_cast<GLenum>(11),
2003      static_cast<GLuint>(12));
2004  EXPECT_EQ(static_cast<uint32>(cmds::StencilMaskSeparate::kCmdId),
2005            cmd.header.command);
2006  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2007  EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
2008  EXPECT_EQ(static_cast<GLuint>(12), cmd.mask);
2009  CheckBytesWrittenMatchesExpectedSize(
2010      next_cmd, sizeof(cmd));
2011}
2012
2013TEST_F(GLES2FormatTest, StencilOp) {
2014  cmds::StencilOp& cmd = *GetBufferAs<cmds::StencilOp>();
2015  void* next_cmd = cmd.Set(
2016      &cmd,
2017      static_cast<GLenum>(11),
2018      static_cast<GLenum>(12),
2019      static_cast<GLenum>(13));
2020  EXPECT_EQ(static_cast<uint32>(cmds::StencilOp::kCmdId),
2021            cmd.header.command);
2022  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2023  EXPECT_EQ(static_cast<GLenum>(11), cmd.fail);
2024  EXPECT_EQ(static_cast<GLenum>(12), cmd.zfail);
2025  EXPECT_EQ(static_cast<GLenum>(13), cmd.zpass);
2026  CheckBytesWrittenMatchesExpectedSize(
2027      next_cmd, sizeof(cmd));
2028}
2029
2030TEST_F(GLES2FormatTest, StencilOpSeparate) {
2031  cmds::StencilOpSeparate& cmd = *GetBufferAs<cmds::StencilOpSeparate>();
2032  void* next_cmd = cmd.Set(
2033      &cmd,
2034      static_cast<GLenum>(11),
2035      static_cast<GLenum>(12),
2036      static_cast<GLenum>(13),
2037      static_cast<GLenum>(14));
2038  EXPECT_EQ(static_cast<uint32>(cmds::StencilOpSeparate::kCmdId),
2039            cmd.header.command);
2040  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2041  EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
2042  EXPECT_EQ(static_cast<GLenum>(12), cmd.fail);
2043  EXPECT_EQ(static_cast<GLenum>(13), cmd.zfail);
2044  EXPECT_EQ(static_cast<GLenum>(14), cmd.zpass);
2045  CheckBytesWrittenMatchesExpectedSize(
2046      next_cmd, sizeof(cmd));
2047}
2048
2049TEST_F(GLES2FormatTest, TexImage2D) {
2050  cmds::TexImage2D& cmd = *GetBufferAs<cmds::TexImage2D>();
2051  void* next_cmd = cmd.Set(
2052      &cmd,
2053      static_cast<GLenum>(11),
2054      static_cast<GLint>(12),
2055      static_cast<GLint>(13),
2056      static_cast<GLsizei>(14),
2057      static_cast<GLsizei>(15),
2058      static_cast<GLint>(16),
2059      static_cast<GLenum>(17),
2060      static_cast<GLenum>(18),
2061      static_cast<uint32>(19),
2062      static_cast<uint32>(20));
2063  EXPECT_EQ(static_cast<uint32>(cmds::TexImage2D::kCmdId),
2064            cmd.header.command);
2065  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2066  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2067  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
2068  EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
2069  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
2070  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
2071  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
2072  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
2073  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
2074  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
2075  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
2076  CheckBytesWrittenMatchesExpectedSize(
2077      next_cmd, sizeof(cmd));
2078}
2079
2080// TODO(gman): Implement test for TexImage2DImmediate
2081TEST_F(GLES2FormatTest, TexParameterf) {
2082  cmds::TexParameterf& cmd = *GetBufferAs<cmds::TexParameterf>();
2083  void* next_cmd = cmd.Set(
2084      &cmd,
2085      static_cast<GLenum>(11),
2086      static_cast<GLenum>(12),
2087      static_cast<GLfloat>(13));
2088  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterf::kCmdId),
2089            cmd.header.command);
2090  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2091  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2092  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2093  EXPECT_EQ(static_cast<GLfloat>(13), cmd.param);
2094  CheckBytesWrittenMatchesExpectedSize(
2095      next_cmd, sizeof(cmd));
2096}
2097
2098TEST_F(GLES2FormatTest, TexParameterfv) {
2099  cmds::TexParameterfv& cmd = *GetBufferAs<cmds::TexParameterfv>();
2100  void* next_cmd = cmd.Set(
2101      &cmd,
2102      static_cast<GLenum>(11),
2103      static_cast<GLenum>(12),
2104      static_cast<uint32>(13),
2105      static_cast<uint32>(14));
2106  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfv::kCmdId),
2107            cmd.header.command);
2108  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2109  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2110  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2111  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
2112  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
2113  CheckBytesWrittenMatchesExpectedSize(
2114      next_cmd, sizeof(cmd));
2115}
2116
2117TEST_F(GLES2FormatTest, TexParameterfvImmediate) {
2118  const int kSomeBaseValueToTestWith = 51;
2119  static GLfloat data[] = {
2120    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2121  };
2122  cmds::TexParameterfvImmediate& cmd =
2123      *GetBufferAs<cmds::TexParameterfvImmediate>();
2124  void* next_cmd = cmd.Set(
2125      &cmd,
2126      static_cast<GLenum>(11),
2127      static_cast<GLenum>(12),
2128      data);
2129  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfvImmediate::kCmdId),
2130            cmd.header.command);
2131  EXPECT_EQ(sizeof(cmd) +
2132            RoundSizeToMultipleOfEntries(sizeof(data)),
2133            cmd.header.size * 4u);
2134  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2135  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2136  CheckBytesWrittenMatchesExpectedSize(
2137      next_cmd, sizeof(cmd) +
2138      RoundSizeToMultipleOfEntries(sizeof(data)));
2139  // TODO(gman): Check that data was inserted;
2140}
2141
2142TEST_F(GLES2FormatTest, TexParameteri) {
2143  cmds::TexParameteri& cmd = *GetBufferAs<cmds::TexParameteri>();
2144  void* next_cmd = cmd.Set(
2145      &cmd,
2146      static_cast<GLenum>(11),
2147      static_cast<GLenum>(12),
2148      static_cast<GLint>(13));
2149  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteri::kCmdId),
2150            cmd.header.command);
2151  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2152  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2153  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2154  EXPECT_EQ(static_cast<GLint>(13), cmd.param);
2155  CheckBytesWrittenMatchesExpectedSize(
2156      next_cmd, sizeof(cmd));
2157}
2158
2159TEST_F(GLES2FormatTest, TexParameteriv) {
2160  cmds::TexParameteriv& cmd = *GetBufferAs<cmds::TexParameteriv>();
2161  void* next_cmd = cmd.Set(
2162      &cmd,
2163      static_cast<GLenum>(11),
2164      static_cast<GLenum>(12),
2165      static_cast<uint32>(13),
2166      static_cast<uint32>(14));
2167  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteriv::kCmdId),
2168            cmd.header.command);
2169  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2170  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2171  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2172  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
2173  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
2174  CheckBytesWrittenMatchesExpectedSize(
2175      next_cmd, sizeof(cmd));
2176}
2177
2178TEST_F(GLES2FormatTest, TexParameterivImmediate) {
2179  const int kSomeBaseValueToTestWith = 51;
2180  static GLint data[] = {
2181    static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2182  };
2183  cmds::TexParameterivImmediate& cmd =
2184      *GetBufferAs<cmds::TexParameterivImmediate>();
2185  void* next_cmd = cmd.Set(
2186      &cmd,
2187      static_cast<GLenum>(11),
2188      static_cast<GLenum>(12),
2189      data);
2190  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterivImmediate::kCmdId),
2191            cmd.header.command);
2192  EXPECT_EQ(sizeof(cmd) +
2193            RoundSizeToMultipleOfEntries(sizeof(data)),
2194            cmd.header.size * 4u);
2195  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2196  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2197  CheckBytesWrittenMatchesExpectedSize(
2198      next_cmd, sizeof(cmd) +
2199      RoundSizeToMultipleOfEntries(sizeof(data)));
2200  // TODO(gman): Check that data was inserted;
2201}
2202
2203TEST_F(GLES2FormatTest, TexSubImage2D) {
2204  cmds::TexSubImage2D& cmd = *GetBufferAs<cmds::TexSubImage2D>();
2205  void* next_cmd = cmd.Set(
2206      &cmd,
2207      static_cast<GLenum>(11),
2208      static_cast<GLint>(12),
2209      static_cast<GLint>(13),
2210      static_cast<GLint>(14),
2211      static_cast<GLsizei>(15),
2212      static_cast<GLsizei>(16),
2213      static_cast<GLenum>(17),
2214      static_cast<GLenum>(18),
2215      static_cast<uint32>(19),
2216      static_cast<uint32>(20),
2217      static_cast<GLboolean>(21));
2218  EXPECT_EQ(static_cast<uint32>(cmds::TexSubImage2D::kCmdId),
2219            cmd.header.command);
2220  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2221  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2222  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
2223  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
2224  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
2225  EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
2226  EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
2227  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
2228  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
2229  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
2230  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
2231  EXPECT_EQ(static_cast<GLboolean>(21), cmd.internal);
2232  CheckBytesWrittenMatchesExpectedSize(
2233      next_cmd, sizeof(cmd));
2234}
2235
2236// TODO(gman): Implement test for TexSubImage2DImmediate
2237TEST_F(GLES2FormatTest, Uniform1f) {
2238  cmds::Uniform1f& cmd = *GetBufferAs<cmds::Uniform1f>();
2239  void* next_cmd = cmd.Set(
2240      &cmd,
2241      static_cast<GLint>(11),
2242      static_cast<GLfloat>(12));
2243  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1f::kCmdId),
2244            cmd.header.command);
2245  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2246  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2247  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2248  CheckBytesWrittenMatchesExpectedSize(
2249      next_cmd, sizeof(cmd));
2250}
2251
2252TEST_F(GLES2FormatTest, Uniform1fv) {
2253  cmds::Uniform1fv& cmd = *GetBufferAs<cmds::Uniform1fv>();
2254  void* next_cmd = cmd.Set(
2255      &cmd,
2256      static_cast<GLint>(11),
2257      static_cast<GLsizei>(12),
2258      static_cast<uint32>(13),
2259      static_cast<uint32>(14));
2260  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fv::kCmdId),
2261            cmd.header.command);
2262  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2263  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2264  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2265  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2266  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2267  CheckBytesWrittenMatchesExpectedSize(
2268      next_cmd, sizeof(cmd));
2269}
2270
2271TEST_F(GLES2FormatTest, Uniform1fvImmediate) {
2272  const int kSomeBaseValueToTestWith = 51;
2273  static GLfloat data[] = {
2274    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2275    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2276  };
2277  cmds::Uniform1fvImmediate& cmd = *GetBufferAs<cmds::Uniform1fvImmediate>();
2278  const GLsizei kNumElements = 2;
2279  const size_t kExpectedCmdSize =
2280      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 1;
2281  void* next_cmd = cmd.Set(
2282      &cmd,
2283      static_cast<GLint>(1),
2284      static_cast<GLsizei>(2),
2285      data);
2286  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fvImmediate::kCmdId),
2287            cmd.header.command);
2288  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2289  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2290  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2291  CheckBytesWrittenMatchesExpectedSize(
2292      next_cmd, sizeof(cmd) +
2293      RoundSizeToMultipleOfEntries(sizeof(data)));
2294  // TODO(gman): Check that data was inserted;
2295}
2296
2297TEST_F(GLES2FormatTest, Uniform1i) {
2298  cmds::Uniform1i& cmd = *GetBufferAs<cmds::Uniform1i>();
2299  void* next_cmd = cmd.Set(
2300      &cmd,
2301      static_cast<GLint>(11),
2302      static_cast<GLint>(12));
2303  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1i::kCmdId),
2304            cmd.header.command);
2305  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2306  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2307  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2308  CheckBytesWrittenMatchesExpectedSize(
2309      next_cmd, sizeof(cmd));
2310}
2311
2312TEST_F(GLES2FormatTest, Uniform1iv) {
2313  cmds::Uniform1iv& cmd = *GetBufferAs<cmds::Uniform1iv>();
2314  void* next_cmd = cmd.Set(
2315      &cmd,
2316      static_cast<GLint>(11),
2317      static_cast<GLsizei>(12),
2318      static_cast<uint32>(13),
2319      static_cast<uint32>(14));
2320  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1iv::kCmdId),
2321            cmd.header.command);
2322  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2323  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2324  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2325  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2326  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2327  CheckBytesWrittenMatchesExpectedSize(
2328      next_cmd, sizeof(cmd));
2329}
2330
2331TEST_F(GLES2FormatTest, Uniform1ivImmediate) {
2332  const int kSomeBaseValueToTestWith = 51;
2333  static GLint data[] = {
2334    static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2335    static_cast<GLint>(kSomeBaseValueToTestWith + 1),
2336  };
2337  cmds::Uniform1ivImmediate& cmd = *GetBufferAs<cmds::Uniform1ivImmediate>();
2338  const GLsizei kNumElements = 2;
2339  const size_t kExpectedCmdSize =
2340      sizeof(cmd) + kNumElements * sizeof(GLint) * 1;
2341  void* next_cmd = cmd.Set(
2342      &cmd,
2343      static_cast<GLint>(1),
2344      static_cast<GLsizei>(2),
2345      data);
2346  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1ivImmediate::kCmdId),
2347            cmd.header.command);
2348  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2349  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2350  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2351  CheckBytesWrittenMatchesExpectedSize(
2352      next_cmd, sizeof(cmd) +
2353      RoundSizeToMultipleOfEntries(sizeof(data)));
2354  // TODO(gman): Check that data was inserted;
2355}
2356
2357TEST_F(GLES2FormatTest, Uniform2f) {
2358  cmds::Uniform2f& cmd = *GetBufferAs<cmds::Uniform2f>();
2359  void* next_cmd = cmd.Set(
2360      &cmd,
2361      static_cast<GLint>(11),
2362      static_cast<GLfloat>(12),
2363      static_cast<GLfloat>(13));
2364  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2f::kCmdId),
2365            cmd.header.command);
2366  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2367  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2368  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2369  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2370  CheckBytesWrittenMatchesExpectedSize(
2371      next_cmd, sizeof(cmd));
2372}
2373
2374TEST_F(GLES2FormatTest, Uniform2fv) {
2375  cmds::Uniform2fv& cmd = *GetBufferAs<cmds::Uniform2fv>();
2376  void* next_cmd = cmd.Set(
2377      &cmd,
2378      static_cast<GLint>(11),
2379      static_cast<GLsizei>(12),
2380      static_cast<uint32>(13),
2381      static_cast<uint32>(14));
2382  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fv::kCmdId),
2383            cmd.header.command);
2384  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2385  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2386  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2387  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2388  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2389  CheckBytesWrittenMatchesExpectedSize(
2390      next_cmd, sizeof(cmd));
2391}
2392
2393TEST_F(GLES2FormatTest, Uniform2fvImmediate) {
2394  const int kSomeBaseValueToTestWith = 51;
2395  static GLfloat data[] = {
2396    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2397    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2398    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2399    static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2400  };
2401  cmds::Uniform2fvImmediate& cmd = *GetBufferAs<cmds::Uniform2fvImmediate>();
2402  const GLsizei kNumElements = 2;
2403  const size_t kExpectedCmdSize =
2404      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 2;
2405  void* next_cmd = cmd.Set(
2406      &cmd,
2407      static_cast<GLint>(1),
2408      static_cast<GLsizei>(2),
2409      data);
2410  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fvImmediate::kCmdId),
2411            cmd.header.command);
2412  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2413  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2414  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2415  CheckBytesWrittenMatchesExpectedSize(
2416      next_cmd, sizeof(cmd) +
2417      RoundSizeToMultipleOfEntries(sizeof(data)));
2418  // TODO(gman): Check that data was inserted;
2419}
2420
2421TEST_F(GLES2FormatTest, Uniform2i) {
2422  cmds::Uniform2i& cmd = *GetBufferAs<cmds::Uniform2i>();
2423  void* next_cmd = cmd.Set(
2424      &cmd,
2425      static_cast<GLint>(11),
2426      static_cast<GLint>(12),
2427      static_cast<GLint>(13));
2428  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2i::kCmdId),
2429            cmd.header.command);
2430  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2431  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2432  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2433  EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2434  CheckBytesWrittenMatchesExpectedSize(
2435      next_cmd, sizeof(cmd));
2436}
2437
2438TEST_F(GLES2FormatTest, Uniform2iv) {
2439  cmds::Uniform2iv& cmd = *GetBufferAs<cmds::Uniform2iv>();
2440  void* next_cmd = cmd.Set(
2441      &cmd,
2442      static_cast<GLint>(11),
2443      static_cast<GLsizei>(12),
2444      static_cast<uint32>(13),
2445      static_cast<uint32>(14));
2446  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2iv::kCmdId),
2447            cmd.header.command);
2448  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2449  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2450  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2451  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2452  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2453  CheckBytesWrittenMatchesExpectedSize(
2454      next_cmd, sizeof(cmd));
2455}
2456
2457TEST_F(GLES2FormatTest, Uniform2ivImmediate) {
2458  const int kSomeBaseValueToTestWith = 51;
2459  static GLint data[] = {
2460    static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2461    static_cast<GLint>(kSomeBaseValueToTestWith + 1),
2462    static_cast<GLint>(kSomeBaseValueToTestWith + 2),
2463    static_cast<GLint>(kSomeBaseValueToTestWith + 3),
2464  };
2465  cmds::Uniform2ivImmediate& cmd = *GetBufferAs<cmds::Uniform2ivImmediate>();
2466  const GLsizei kNumElements = 2;
2467  const size_t kExpectedCmdSize =
2468      sizeof(cmd) + kNumElements * sizeof(GLint) * 2;
2469  void* next_cmd = cmd.Set(
2470      &cmd,
2471      static_cast<GLint>(1),
2472      static_cast<GLsizei>(2),
2473      data);
2474  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2ivImmediate::kCmdId),
2475            cmd.header.command);
2476  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2477  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2478  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2479  CheckBytesWrittenMatchesExpectedSize(
2480      next_cmd, sizeof(cmd) +
2481      RoundSizeToMultipleOfEntries(sizeof(data)));
2482  // TODO(gman): Check that data was inserted;
2483}
2484
2485TEST_F(GLES2FormatTest, Uniform3f) {
2486  cmds::Uniform3f& cmd = *GetBufferAs<cmds::Uniform3f>();
2487  void* next_cmd = cmd.Set(
2488      &cmd,
2489      static_cast<GLint>(11),
2490      static_cast<GLfloat>(12),
2491      static_cast<GLfloat>(13),
2492      static_cast<GLfloat>(14));
2493  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3f::kCmdId),
2494            cmd.header.command);
2495  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2496  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2497  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2498  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2499  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2500  CheckBytesWrittenMatchesExpectedSize(
2501      next_cmd, sizeof(cmd));
2502}
2503
2504TEST_F(GLES2FormatTest, Uniform3fv) {
2505  cmds::Uniform3fv& cmd = *GetBufferAs<cmds::Uniform3fv>();
2506  void* next_cmd = cmd.Set(
2507      &cmd,
2508      static_cast<GLint>(11),
2509      static_cast<GLsizei>(12),
2510      static_cast<uint32>(13),
2511      static_cast<uint32>(14));
2512  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fv::kCmdId),
2513            cmd.header.command);
2514  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2515  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2516  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2517  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2518  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2519  CheckBytesWrittenMatchesExpectedSize(
2520      next_cmd, sizeof(cmd));
2521}
2522
2523TEST_F(GLES2FormatTest, Uniform3fvImmediate) {
2524  const int kSomeBaseValueToTestWith = 51;
2525  static GLfloat data[] = {
2526    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2527    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2528    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2529    static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2530    static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2531    static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2532  };
2533  cmds::Uniform3fvImmediate& cmd = *GetBufferAs<cmds::Uniform3fvImmediate>();
2534  const GLsizei kNumElements = 2;
2535  const size_t kExpectedCmdSize =
2536      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 3;
2537  void* next_cmd = cmd.Set(
2538      &cmd,
2539      static_cast<GLint>(1),
2540      static_cast<GLsizei>(2),
2541      data);
2542  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fvImmediate::kCmdId),
2543            cmd.header.command);
2544  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2545  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2546  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2547  CheckBytesWrittenMatchesExpectedSize(
2548      next_cmd, sizeof(cmd) +
2549      RoundSizeToMultipleOfEntries(sizeof(data)));
2550  // TODO(gman): Check that data was inserted;
2551}
2552
2553TEST_F(GLES2FormatTest, Uniform3i) {
2554  cmds::Uniform3i& cmd = *GetBufferAs<cmds::Uniform3i>();
2555  void* next_cmd = cmd.Set(
2556      &cmd,
2557      static_cast<GLint>(11),
2558      static_cast<GLint>(12),
2559      static_cast<GLint>(13),
2560      static_cast<GLint>(14));
2561  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3i::kCmdId),
2562            cmd.header.command);
2563  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2564  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2565  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2566  EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2567  EXPECT_EQ(static_cast<GLint>(14), cmd.z);
2568  CheckBytesWrittenMatchesExpectedSize(
2569      next_cmd, sizeof(cmd));
2570}
2571
2572TEST_F(GLES2FormatTest, Uniform3iv) {
2573  cmds::Uniform3iv& cmd = *GetBufferAs<cmds::Uniform3iv>();
2574  void* next_cmd = cmd.Set(
2575      &cmd,
2576      static_cast<GLint>(11),
2577      static_cast<GLsizei>(12),
2578      static_cast<uint32>(13),
2579      static_cast<uint32>(14));
2580  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3iv::kCmdId),
2581            cmd.header.command);
2582  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2583  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2584  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2585  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2586  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2587  CheckBytesWrittenMatchesExpectedSize(
2588      next_cmd, sizeof(cmd));
2589}
2590
2591TEST_F(GLES2FormatTest, Uniform3ivImmediate) {
2592  const int kSomeBaseValueToTestWith = 51;
2593  static GLint data[] = {
2594    static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2595    static_cast<GLint>(kSomeBaseValueToTestWith + 1),
2596    static_cast<GLint>(kSomeBaseValueToTestWith + 2),
2597    static_cast<GLint>(kSomeBaseValueToTestWith + 3),
2598    static_cast<GLint>(kSomeBaseValueToTestWith + 4),
2599    static_cast<GLint>(kSomeBaseValueToTestWith + 5),
2600  };
2601  cmds::Uniform3ivImmediate& cmd = *GetBufferAs<cmds::Uniform3ivImmediate>();
2602  const GLsizei kNumElements = 2;
2603  const size_t kExpectedCmdSize =
2604      sizeof(cmd) + kNumElements * sizeof(GLint) * 3;
2605  void* next_cmd = cmd.Set(
2606      &cmd,
2607      static_cast<GLint>(1),
2608      static_cast<GLsizei>(2),
2609      data);
2610  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3ivImmediate::kCmdId),
2611            cmd.header.command);
2612  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2613  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2614  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2615  CheckBytesWrittenMatchesExpectedSize(
2616      next_cmd, sizeof(cmd) +
2617      RoundSizeToMultipleOfEntries(sizeof(data)));
2618  // TODO(gman): Check that data was inserted;
2619}
2620
2621TEST_F(GLES2FormatTest, Uniform4f) {
2622  cmds::Uniform4f& cmd = *GetBufferAs<cmds::Uniform4f>();
2623  void* next_cmd = cmd.Set(
2624      &cmd,
2625      static_cast<GLint>(11),
2626      static_cast<GLfloat>(12),
2627      static_cast<GLfloat>(13),
2628      static_cast<GLfloat>(14),
2629      static_cast<GLfloat>(15));
2630  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4f::kCmdId),
2631            cmd.header.command);
2632  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2633  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2634  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2635  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2636  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2637  EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
2638  CheckBytesWrittenMatchesExpectedSize(
2639      next_cmd, sizeof(cmd));
2640}
2641
2642TEST_F(GLES2FormatTest, Uniform4fv) {
2643  cmds::Uniform4fv& cmd = *GetBufferAs<cmds::Uniform4fv>();
2644  void* next_cmd = cmd.Set(
2645      &cmd,
2646      static_cast<GLint>(11),
2647      static_cast<GLsizei>(12),
2648      static_cast<uint32>(13),
2649      static_cast<uint32>(14));
2650  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fv::kCmdId),
2651            cmd.header.command);
2652  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2653  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2654  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2655  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2656  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2657  CheckBytesWrittenMatchesExpectedSize(
2658      next_cmd, sizeof(cmd));
2659}
2660
2661TEST_F(GLES2FormatTest, Uniform4fvImmediate) {
2662  const int kSomeBaseValueToTestWith = 51;
2663  static GLfloat data[] = {
2664    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2665    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2666    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2667    static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2668    static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2669    static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2670    static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2671    static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
2672  };
2673  cmds::Uniform4fvImmediate& cmd = *GetBufferAs<cmds::Uniform4fvImmediate>();
2674  const GLsizei kNumElements = 2;
2675  const size_t kExpectedCmdSize =
2676      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
2677  void* next_cmd = cmd.Set(
2678      &cmd,
2679      static_cast<GLint>(1),
2680      static_cast<GLsizei>(2),
2681      data);
2682  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fvImmediate::kCmdId),
2683            cmd.header.command);
2684  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2685  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2686  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2687  CheckBytesWrittenMatchesExpectedSize(
2688      next_cmd, sizeof(cmd) +
2689      RoundSizeToMultipleOfEntries(sizeof(data)));
2690  // TODO(gman): Check that data was inserted;
2691}
2692
2693TEST_F(GLES2FormatTest, Uniform4i) {
2694  cmds::Uniform4i& cmd = *GetBufferAs<cmds::Uniform4i>();
2695  void* next_cmd = cmd.Set(
2696      &cmd,
2697      static_cast<GLint>(11),
2698      static_cast<GLint>(12),
2699      static_cast<GLint>(13),
2700      static_cast<GLint>(14),
2701      static_cast<GLint>(15));
2702  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4i::kCmdId),
2703            cmd.header.command);
2704  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2705  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2706  EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2707  EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2708  EXPECT_EQ(static_cast<GLint>(14), cmd.z);
2709  EXPECT_EQ(static_cast<GLint>(15), cmd.w);
2710  CheckBytesWrittenMatchesExpectedSize(
2711      next_cmd, sizeof(cmd));
2712}
2713
2714TEST_F(GLES2FormatTest, Uniform4iv) {
2715  cmds::Uniform4iv& cmd = *GetBufferAs<cmds::Uniform4iv>();
2716  void* next_cmd = cmd.Set(
2717      &cmd,
2718      static_cast<GLint>(11),
2719      static_cast<GLsizei>(12),
2720      static_cast<uint32>(13),
2721      static_cast<uint32>(14));
2722  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4iv::kCmdId),
2723            cmd.header.command);
2724  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2725  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2726  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2727  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2728  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2729  CheckBytesWrittenMatchesExpectedSize(
2730      next_cmd, sizeof(cmd));
2731}
2732
2733TEST_F(GLES2FormatTest, Uniform4ivImmediate) {
2734  const int kSomeBaseValueToTestWith = 51;
2735  static GLint data[] = {
2736    static_cast<GLint>(kSomeBaseValueToTestWith + 0),
2737    static_cast<GLint>(kSomeBaseValueToTestWith + 1),
2738    static_cast<GLint>(kSomeBaseValueToTestWith + 2),
2739    static_cast<GLint>(kSomeBaseValueToTestWith + 3),
2740    static_cast<GLint>(kSomeBaseValueToTestWith + 4),
2741    static_cast<GLint>(kSomeBaseValueToTestWith + 5),
2742    static_cast<GLint>(kSomeBaseValueToTestWith + 6),
2743    static_cast<GLint>(kSomeBaseValueToTestWith + 7),
2744  };
2745  cmds::Uniform4ivImmediate& cmd = *GetBufferAs<cmds::Uniform4ivImmediate>();
2746  const GLsizei kNumElements = 2;
2747  const size_t kExpectedCmdSize =
2748      sizeof(cmd) + kNumElements * sizeof(GLint) * 4;
2749  void* next_cmd = cmd.Set(
2750      &cmd,
2751      static_cast<GLint>(1),
2752      static_cast<GLsizei>(2),
2753      data);
2754  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4ivImmediate::kCmdId),
2755            cmd.header.command);
2756  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2757  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2758  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2759  CheckBytesWrittenMatchesExpectedSize(
2760      next_cmd, sizeof(cmd) +
2761      RoundSizeToMultipleOfEntries(sizeof(data)));
2762  // TODO(gman): Check that data was inserted;
2763}
2764
2765TEST_F(GLES2FormatTest, UniformMatrix2fv) {
2766  cmds::UniformMatrix2fv& cmd = *GetBufferAs<cmds::UniformMatrix2fv>();
2767  void* next_cmd = cmd.Set(
2768      &cmd,
2769      static_cast<GLint>(11),
2770      static_cast<GLsizei>(12),
2771      static_cast<GLboolean>(13),
2772      static_cast<uint32>(14),
2773      static_cast<uint32>(15));
2774  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fv::kCmdId),
2775            cmd.header.command);
2776  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2777  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2778  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2779  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2780  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2781  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2782  CheckBytesWrittenMatchesExpectedSize(
2783      next_cmd, sizeof(cmd));
2784}
2785
2786TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
2787  const int kSomeBaseValueToTestWith = 51;
2788  static GLfloat data[] = {
2789    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2790    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2791    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2792    static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2793    static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2794    static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2795    static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2796    static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
2797  };
2798  cmds::UniformMatrix2fvImmediate& cmd =
2799      *GetBufferAs<cmds::UniformMatrix2fvImmediate>();
2800  const GLsizei kNumElements = 2;
2801  const size_t kExpectedCmdSize =
2802      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
2803  void* next_cmd = cmd.Set(
2804      &cmd,
2805      static_cast<GLint>(1),
2806      static_cast<GLsizei>(2),
2807      static_cast<GLboolean>(3),
2808      data);
2809  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fvImmediate::kCmdId),
2810            cmd.header.command);
2811  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2812  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2813  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2814  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2815  CheckBytesWrittenMatchesExpectedSize(
2816      next_cmd, sizeof(cmd) +
2817      RoundSizeToMultipleOfEntries(sizeof(data)));
2818  // TODO(gman): Check that data was inserted;
2819}
2820
2821TEST_F(GLES2FormatTest, UniformMatrix3fv) {
2822  cmds::UniformMatrix3fv& cmd = *GetBufferAs<cmds::UniformMatrix3fv>();
2823  void* next_cmd = cmd.Set(
2824      &cmd,
2825      static_cast<GLint>(11),
2826      static_cast<GLsizei>(12),
2827      static_cast<GLboolean>(13),
2828      static_cast<uint32>(14),
2829      static_cast<uint32>(15));
2830  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fv::kCmdId),
2831            cmd.header.command);
2832  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2833  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2834  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2835  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2836  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2837  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2838  CheckBytesWrittenMatchesExpectedSize(
2839      next_cmd, sizeof(cmd));
2840}
2841
2842TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
2843  const int kSomeBaseValueToTestWith = 51;
2844  static GLfloat data[] = {
2845    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2846    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2847    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2848    static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2849    static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2850    static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2851    static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2852    static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
2853    static_cast<GLfloat>(kSomeBaseValueToTestWith + 8),
2854    static_cast<GLfloat>(kSomeBaseValueToTestWith + 9),
2855    static_cast<GLfloat>(kSomeBaseValueToTestWith + 10),
2856    static_cast<GLfloat>(kSomeBaseValueToTestWith + 11),
2857    static_cast<GLfloat>(kSomeBaseValueToTestWith + 12),
2858    static_cast<GLfloat>(kSomeBaseValueToTestWith + 13),
2859    static_cast<GLfloat>(kSomeBaseValueToTestWith + 14),
2860    static_cast<GLfloat>(kSomeBaseValueToTestWith + 15),
2861    static_cast<GLfloat>(kSomeBaseValueToTestWith + 16),
2862    static_cast<GLfloat>(kSomeBaseValueToTestWith + 17),
2863  };
2864  cmds::UniformMatrix3fvImmediate& cmd =
2865      *GetBufferAs<cmds::UniformMatrix3fvImmediate>();
2866  const GLsizei kNumElements = 2;
2867  const size_t kExpectedCmdSize =
2868      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 9;
2869  void* next_cmd = cmd.Set(
2870      &cmd,
2871      static_cast<GLint>(1),
2872      static_cast<GLsizei>(2),
2873      static_cast<GLboolean>(3),
2874      data);
2875  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fvImmediate::kCmdId),
2876            cmd.header.command);
2877  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2878  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2879  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2880  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2881  CheckBytesWrittenMatchesExpectedSize(
2882      next_cmd, sizeof(cmd) +
2883      RoundSizeToMultipleOfEntries(sizeof(data)));
2884  // TODO(gman): Check that data was inserted;
2885}
2886
2887TEST_F(GLES2FormatTest, UniformMatrix4fv) {
2888  cmds::UniformMatrix4fv& cmd = *GetBufferAs<cmds::UniformMatrix4fv>();
2889  void* next_cmd = cmd.Set(
2890      &cmd,
2891      static_cast<GLint>(11),
2892      static_cast<GLsizei>(12),
2893      static_cast<GLboolean>(13),
2894      static_cast<uint32>(14),
2895      static_cast<uint32>(15));
2896  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fv::kCmdId),
2897            cmd.header.command);
2898  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2899  EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2900  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2901  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2902  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2903  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2904  CheckBytesWrittenMatchesExpectedSize(
2905      next_cmd, sizeof(cmd));
2906}
2907
2908TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
2909  const int kSomeBaseValueToTestWith = 51;
2910  static GLfloat data[] = {
2911    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
2912    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
2913    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
2914    static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
2915    static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
2916    static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
2917    static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
2918    static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
2919    static_cast<GLfloat>(kSomeBaseValueToTestWith + 8),
2920    static_cast<GLfloat>(kSomeBaseValueToTestWith + 9),
2921    static_cast<GLfloat>(kSomeBaseValueToTestWith + 10),
2922    static_cast<GLfloat>(kSomeBaseValueToTestWith + 11),
2923    static_cast<GLfloat>(kSomeBaseValueToTestWith + 12),
2924    static_cast<GLfloat>(kSomeBaseValueToTestWith + 13),
2925    static_cast<GLfloat>(kSomeBaseValueToTestWith + 14),
2926    static_cast<GLfloat>(kSomeBaseValueToTestWith + 15),
2927    static_cast<GLfloat>(kSomeBaseValueToTestWith + 16),
2928    static_cast<GLfloat>(kSomeBaseValueToTestWith + 17),
2929    static_cast<GLfloat>(kSomeBaseValueToTestWith + 18),
2930    static_cast<GLfloat>(kSomeBaseValueToTestWith + 19),
2931    static_cast<GLfloat>(kSomeBaseValueToTestWith + 20),
2932    static_cast<GLfloat>(kSomeBaseValueToTestWith + 21),
2933    static_cast<GLfloat>(kSomeBaseValueToTestWith + 22),
2934    static_cast<GLfloat>(kSomeBaseValueToTestWith + 23),
2935    static_cast<GLfloat>(kSomeBaseValueToTestWith + 24),
2936    static_cast<GLfloat>(kSomeBaseValueToTestWith + 25),
2937    static_cast<GLfloat>(kSomeBaseValueToTestWith + 26),
2938    static_cast<GLfloat>(kSomeBaseValueToTestWith + 27),
2939    static_cast<GLfloat>(kSomeBaseValueToTestWith + 28),
2940    static_cast<GLfloat>(kSomeBaseValueToTestWith + 29),
2941    static_cast<GLfloat>(kSomeBaseValueToTestWith + 30),
2942    static_cast<GLfloat>(kSomeBaseValueToTestWith + 31),
2943  };
2944  cmds::UniformMatrix4fvImmediate& cmd =
2945      *GetBufferAs<cmds::UniformMatrix4fvImmediate>();
2946  const GLsizei kNumElements = 2;
2947  const size_t kExpectedCmdSize =
2948      sizeof(cmd) + kNumElements * sizeof(GLfloat) * 16;
2949  void* next_cmd = cmd.Set(
2950      &cmd,
2951      static_cast<GLint>(1),
2952      static_cast<GLsizei>(2),
2953      static_cast<GLboolean>(3),
2954      data);
2955  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fvImmediate::kCmdId),
2956            cmd.header.command);
2957  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2958  EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2959  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2960  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2961  CheckBytesWrittenMatchesExpectedSize(
2962      next_cmd, sizeof(cmd) +
2963      RoundSizeToMultipleOfEntries(sizeof(data)));
2964  // TODO(gman): Check that data was inserted;
2965}
2966
2967TEST_F(GLES2FormatTest, UseProgram) {
2968  cmds::UseProgram& cmd = *GetBufferAs<cmds::UseProgram>();
2969  void* next_cmd = cmd.Set(
2970      &cmd,
2971      static_cast<GLuint>(11));
2972  EXPECT_EQ(static_cast<uint32>(cmds::UseProgram::kCmdId),
2973            cmd.header.command);
2974  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2975  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
2976  CheckBytesWrittenMatchesExpectedSize(
2977      next_cmd, sizeof(cmd));
2978}
2979
2980TEST_F(GLES2FormatTest, ValidateProgram) {
2981  cmds::ValidateProgram& cmd = *GetBufferAs<cmds::ValidateProgram>();
2982  void* next_cmd = cmd.Set(
2983      &cmd,
2984      static_cast<GLuint>(11));
2985  EXPECT_EQ(static_cast<uint32>(cmds::ValidateProgram::kCmdId),
2986            cmd.header.command);
2987  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2988  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
2989  CheckBytesWrittenMatchesExpectedSize(
2990      next_cmd, sizeof(cmd));
2991}
2992
2993TEST_F(GLES2FormatTest, VertexAttrib1f) {
2994  cmds::VertexAttrib1f& cmd = *GetBufferAs<cmds::VertexAttrib1f>();
2995  void* next_cmd = cmd.Set(
2996      &cmd,
2997      static_cast<GLuint>(11),
2998      static_cast<GLfloat>(12));
2999  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1f::kCmdId),
3000            cmd.header.command);
3001  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3002  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3003  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3004  CheckBytesWrittenMatchesExpectedSize(
3005      next_cmd, sizeof(cmd));
3006}
3007
3008TEST_F(GLES2FormatTest, VertexAttrib1fv) {
3009  cmds::VertexAttrib1fv& cmd = *GetBufferAs<cmds::VertexAttrib1fv>();
3010  void* next_cmd = cmd.Set(
3011      &cmd,
3012      static_cast<GLuint>(11),
3013      static_cast<uint32>(12),
3014      static_cast<uint32>(13));
3015  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fv::kCmdId),
3016            cmd.header.command);
3017  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3018  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3019  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3020  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3021  CheckBytesWrittenMatchesExpectedSize(
3022      next_cmd, sizeof(cmd));
3023}
3024
3025TEST_F(GLES2FormatTest, VertexAttrib1fvImmediate) {
3026  const int kSomeBaseValueToTestWith = 51;
3027  static GLfloat data[] = {
3028    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
3029  };
3030  cmds::VertexAttrib1fvImmediate& cmd =
3031      *GetBufferAs<cmds::VertexAttrib1fvImmediate>();
3032  void* next_cmd = cmd.Set(
3033      &cmd,
3034      static_cast<GLuint>(11),
3035      data);
3036  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fvImmediate::kCmdId),
3037            cmd.header.command);
3038  EXPECT_EQ(sizeof(cmd) +
3039            RoundSizeToMultipleOfEntries(sizeof(data)),
3040            cmd.header.size * 4u);
3041  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3042  CheckBytesWrittenMatchesExpectedSize(
3043      next_cmd, sizeof(cmd) +
3044      RoundSizeToMultipleOfEntries(sizeof(data)));
3045  // TODO(gman): Check that data was inserted;
3046}
3047
3048TEST_F(GLES2FormatTest, VertexAttrib2f) {
3049  cmds::VertexAttrib2f& cmd = *GetBufferAs<cmds::VertexAttrib2f>();
3050  void* next_cmd = cmd.Set(
3051      &cmd,
3052      static_cast<GLuint>(11),
3053      static_cast<GLfloat>(12),
3054      static_cast<GLfloat>(13));
3055  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2f::kCmdId),
3056            cmd.header.command);
3057  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3058  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3059  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3060  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
3061  CheckBytesWrittenMatchesExpectedSize(
3062      next_cmd, sizeof(cmd));
3063}
3064
3065TEST_F(GLES2FormatTest, VertexAttrib2fv) {
3066  cmds::VertexAttrib2fv& cmd = *GetBufferAs<cmds::VertexAttrib2fv>();
3067  void* next_cmd = cmd.Set(
3068      &cmd,
3069      static_cast<GLuint>(11),
3070      static_cast<uint32>(12),
3071      static_cast<uint32>(13));
3072  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fv::kCmdId),
3073            cmd.header.command);
3074  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3075  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3076  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3077  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3078  CheckBytesWrittenMatchesExpectedSize(
3079      next_cmd, sizeof(cmd));
3080}
3081
3082TEST_F(GLES2FormatTest, VertexAttrib2fvImmediate) {
3083  const int kSomeBaseValueToTestWith = 51;
3084  static GLfloat data[] = {
3085    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
3086    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
3087  };
3088  cmds::VertexAttrib2fvImmediate& cmd =
3089      *GetBufferAs<cmds::VertexAttrib2fvImmediate>();
3090  void* next_cmd = cmd.Set(
3091      &cmd,
3092      static_cast<GLuint>(11),
3093      data);
3094  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fvImmediate::kCmdId),
3095            cmd.header.command);
3096  EXPECT_EQ(sizeof(cmd) +
3097            RoundSizeToMultipleOfEntries(sizeof(data)),
3098            cmd.header.size * 4u);
3099  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3100  CheckBytesWrittenMatchesExpectedSize(
3101      next_cmd, sizeof(cmd) +
3102      RoundSizeToMultipleOfEntries(sizeof(data)));
3103  // TODO(gman): Check that data was inserted;
3104}
3105
3106TEST_F(GLES2FormatTest, VertexAttrib3f) {
3107  cmds::VertexAttrib3f& cmd = *GetBufferAs<cmds::VertexAttrib3f>();
3108  void* next_cmd = cmd.Set(
3109      &cmd,
3110      static_cast<GLuint>(11),
3111      static_cast<GLfloat>(12),
3112      static_cast<GLfloat>(13),
3113      static_cast<GLfloat>(14));
3114  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3f::kCmdId),
3115            cmd.header.command);
3116  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3117  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3118  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3119  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
3120  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
3121  CheckBytesWrittenMatchesExpectedSize(
3122      next_cmd, sizeof(cmd));
3123}
3124
3125TEST_F(GLES2FormatTest, VertexAttrib3fv) {
3126  cmds::VertexAttrib3fv& cmd = *GetBufferAs<cmds::VertexAttrib3fv>();
3127  void* next_cmd = cmd.Set(
3128      &cmd,
3129      static_cast<GLuint>(11),
3130      static_cast<uint32>(12),
3131      static_cast<uint32>(13));
3132  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fv::kCmdId),
3133            cmd.header.command);
3134  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3135  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3136  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3137  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3138  CheckBytesWrittenMatchesExpectedSize(
3139      next_cmd, sizeof(cmd));
3140}
3141
3142TEST_F(GLES2FormatTest, VertexAttrib3fvImmediate) {
3143  const int kSomeBaseValueToTestWith = 51;
3144  static GLfloat data[] = {
3145    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
3146    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
3147    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
3148  };
3149  cmds::VertexAttrib3fvImmediate& cmd =
3150      *GetBufferAs<cmds::VertexAttrib3fvImmediate>();
3151  void* next_cmd = cmd.Set(
3152      &cmd,
3153      static_cast<GLuint>(11),
3154      data);
3155  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fvImmediate::kCmdId),
3156            cmd.header.command);
3157  EXPECT_EQ(sizeof(cmd) +
3158            RoundSizeToMultipleOfEntries(sizeof(data)),
3159            cmd.header.size * 4u);
3160  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3161  CheckBytesWrittenMatchesExpectedSize(
3162      next_cmd, sizeof(cmd) +
3163      RoundSizeToMultipleOfEntries(sizeof(data)));
3164  // TODO(gman): Check that data was inserted;
3165}
3166
3167TEST_F(GLES2FormatTest, VertexAttrib4f) {
3168  cmds::VertexAttrib4f& cmd = *GetBufferAs<cmds::VertexAttrib4f>();
3169  void* next_cmd = cmd.Set(
3170      &cmd,
3171      static_cast<GLuint>(11),
3172      static_cast<GLfloat>(12),
3173      static_cast<GLfloat>(13),
3174      static_cast<GLfloat>(14),
3175      static_cast<GLfloat>(15));
3176  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4f::kCmdId),
3177            cmd.header.command);
3178  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3179  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3180  EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3181  EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
3182  EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
3183  EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
3184  CheckBytesWrittenMatchesExpectedSize(
3185      next_cmd, sizeof(cmd));
3186}
3187
3188TEST_F(GLES2FormatTest, VertexAttrib4fv) {
3189  cmds::VertexAttrib4fv& cmd = *GetBufferAs<cmds::VertexAttrib4fv>();
3190  void* next_cmd = cmd.Set(
3191      &cmd,
3192      static_cast<GLuint>(11),
3193      static_cast<uint32>(12),
3194      static_cast<uint32>(13));
3195  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fv::kCmdId),
3196            cmd.header.command);
3197  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3198  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3199  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3200  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3201  CheckBytesWrittenMatchesExpectedSize(
3202      next_cmd, sizeof(cmd));
3203}
3204
3205TEST_F(GLES2FormatTest, VertexAttrib4fvImmediate) {
3206  const int kSomeBaseValueToTestWith = 51;
3207  static GLfloat data[] = {
3208    static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
3209    static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
3210    static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
3211    static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
3212  };
3213  cmds::VertexAttrib4fvImmediate& cmd =
3214      *GetBufferAs<cmds::VertexAttrib4fvImmediate>();
3215  void* next_cmd = cmd.Set(
3216      &cmd,
3217      static_cast<GLuint>(11),
3218      data);
3219  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fvImmediate::kCmdId),
3220            cmd.header.command);
3221  EXPECT_EQ(sizeof(cmd) +
3222            RoundSizeToMultipleOfEntries(sizeof(data)),
3223            cmd.header.size * 4u);
3224  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3225  CheckBytesWrittenMatchesExpectedSize(
3226      next_cmd, sizeof(cmd) +
3227      RoundSizeToMultipleOfEntries(sizeof(data)));
3228  // TODO(gman): Check that data was inserted;
3229}
3230
3231TEST_F(GLES2FormatTest, VertexAttribPointer) {
3232  cmds::VertexAttribPointer& cmd = *GetBufferAs<cmds::VertexAttribPointer>();
3233  void* next_cmd = cmd.Set(
3234      &cmd,
3235      static_cast<GLuint>(11),
3236      static_cast<GLint>(12),
3237      static_cast<GLenum>(13),
3238      static_cast<GLboolean>(14),
3239      static_cast<GLsizei>(15),
3240      static_cast<GLuint>(16));
3241  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribPointer::kCmdId),
3242            cmd.header.command);
3243  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3244  EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3245  EXPECT_EQ(static_cast<GLint>(12), cmd.size);
3246  EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3247  EXPECT_EQ(static_cast<GLboolean>(14), cmd.normalized);
3248  EXPECT_EQ(static_cast<GLsizei>(15), cmd.stride);
3249  EXPECT_EQ(static_cast<GLuint>(16), cmd.offset);
3250  CheckBytesWrittenMatchesExpectedSize(
3251      next_cmd, sizeof(cmd));
3252}
3253
3254TEST_F(GLES2FormatTest, Viewport) {
3255  cmds::Viewport& cmd = *GetBufferAs<cmds::Viewport>();
3256  void* next_cmd = cmd.Set(
3257      &cmd,
3258      static_cast<GLint>(11),
3259      static_cast<GLint>(12),
3260      static_cast<GLsizei>(13),
3261      static_cast<GLsizei>(14));
3262  EXPECT_EQ(static_cast<uint32>(cmds::Viewport::kCmdId),
3263            cmd.header.command);
3264  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3265  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
3266  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
3267  EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
3268  EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
3269  CheckBytesWrittenMatchesExpectedSize(
3270      next_cmd, sizeof(cmd));
3271}
3272
3273TEST_F(GLES2FormatTest, BlitFramebufferEXT) {
3274  cmds::BlitFramebufferEXT& cmd = *GetBufferAs<cmds::BlitFramebufferEXT>();
3275  void* next_cmd = cmd.Set(
3276      &cmd,
3277      static_cast<GLint>(11),
3278      static_cast<GLint>(12),
3279      static_cast<GLint>(13),
3280      static_cast<GLint>(14),
3281      static_cast<GLint>(15),
3282      static_cast<GLint>(16),
3283      static_cast<GLint>(17),
3284      static_cast<GLint>(18),
3285      static_cast<GLbitfield>(19),
3286      static_cast<GLenum>(20));
3287  EXPECT_EQ(static_cast<uint32>(cmds::BlitFramebufferEXT::kCmdId),
3288            cmd.header.command);
3289  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3290  EXPECT_EQ(static_cast<GLint>(11), cmd.srcX0);
3291  EXPECT_EQ(static_cast<GLint>(12), cmd.srcY0);
3292  EXPECT_EQ(static_cast<GLint>(13), cmd.srcX1);
3293  EXPECT_EQ(static_cast<GLint>(14), cmd.srcY1);
3294  EXPECT_EQ(static_cast<GLint>(15), cmd.dstX0);
3295  EXPECT_EQ(static_cast<GLint>(16), cmd.dstY0);
3296  EXPECT_EQ(static_cast<GLint>(17), cmd.dstX1);
3297  EXPECT_EQ(static_cast<GLint>(18), cmd.dstY1);
3298  EXPECT_EQ(static_cast<GLbitfield>(19), cmd.mask);
3299  EXPECT_EQ(static_cast<GLenum>(20), cmd.filter);
3300  CheckBytesWrittenMatchesExpectedSize(
3301      next_cmd, sizeof(cmd));
3302}
3303
3304TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
3305  cmds::RenderbufferStorageMultisampleEXT& cmd =
3306      *GetBufferAs<cmds::RenderbufferStorageMultisampleEXT>();
3307  void* next_cmd = cmd.Set(
3308      &cmd,
3309      static_cast<GLenum>(11),
3310      static_cast<GLsizei>(12),
3311      static_cast<GLenum>(13),
3312      static_cast<GLsizei>(14),
3313      static_cast<GLsizei>(15));
3314  EXPECT_EQ(
3315      static_cast<uint32>(cmds::RenderbufferStorageMultisampleEXT::kCmdId),
3316            cmd.header.command);
3317  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3318  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3319  EXPECT_EQ(static_cast<GLsizei>(12), cmd.samples);
3320  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
3321  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
3322  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
3323  CheckBytesWrittenMatchesExpectedSize(
3324      next_cmd, sizeof(cmd));
3325}
3326
3327TEST_F(GLES2FormatTest, FramebufferTexture2DMultisampleEXT) {
3328  cmds::FramebufferTexture2DMultisampleEXT& cmd =
3329      *GetBufferAs<cmds::FramebufferTexture2DMultisampleEXT>();
3330  void* next_cmd = cmd.Set(
3331      &cmd,
3332      static_cast<GLenum>(11),
3333      static_cast<GLenum>(12),
3334      static_cast<GLenum>(13),
3335      static_cast<GLuint>(14),
3336      static_cast<GLint>(15),
3337      static_cast<GLsizei>(16));
3338  EXPECT_EQ(
3339      static_cast<uint32>(cmds::FramebufferTexture2DMultisampleEXT::kCmdId),
3340            cmd.header.command);
3341  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3342  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3343  EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
3344  EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
3345  EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
3346  EXPECT_EQ(static_cast<GLint>(15), cmd.level);
3347  EXPECT_EQ(static_cast<GLsizei>(16), cmd.samples);
3348  CheckBytesWrittenMatchesExpectedSize(
3349      next_cmd, sizeof(cmd));
3350}
3351
3352TEST_F(GLES2FormatTest, TexStorage2DEXT) {
3353  cmds::TexStorage2DEXT& cmd = *GetBufferAs<cmds::TexStorage2DEXT>();
3354  void* next_cmd = cmd.Set(
3355      &cmd,
3356      static_cast<GLenum>(11),
3357      static_cast<GLsizei>(12),
3358      static_cast<GLenum>(13),
3359      static_cast<GLsizei>(14),
3360      static_cast<GLsizei>(15));
3361  EXPECT_EQ(static_cast<uint32>(cmds::TexStorage2DEXT::kCmdId),
3362            cmd.header.command);
3363  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3364  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3365  EXPECT_EQ(static_cast<GLsizei>(12), cmd.levels);
3366  EXPECT_EQ(static_cast<GLenum>(13), cmd.internalFormat);
3367  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
3368  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
3369  CheckBytesWrittenMatchesExpectedSize(
3370      next_cmd, sizeof(cmd));
3371}
3372
3373TEST_F(GLES2FormatTest, GenQueriesEXT) {
3374  cmds::GenQueriesEXT& cmd = *GetBufferAs<cmds::GenQueriesEXT>();
3375  void* next_cmd = cmd.Set(
3376      &cmd,
3377      static_cast<GLsizei>(11),
3378      static_cast<uint32>(12),
3379      static_cast<uint32>(13));
3380  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXT::kCmdId),
3381            cmd.header.command);
3382  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3383  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3384  EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
3385  EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
3386  CheckBytesWrittenMatchesExpectedSize(
3387      next_cmd, sizeof(cmd));
3388}
3389
3390TEST_F(GLES2FormatTest, GenQueriesEXTImmediate) {
3391  static GLuint ids[] = { 12, 23, 34, };
3392  cmds::GenQueriesEXTImmediate& cmd =
3393      *GetBufferAs<cmds::GenQueriesEXTImmediate>();
3394  void* next_cmd = cmd.Set(
3395      &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3396  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXTImmediate::kCmdId),
3397            cmd.header.command);
3398  EXPECT_EQ(sizeof(cmd) +
3399            RoundSizeToMultipleOfEntries(cmd.n * 4u),
3400            cmd.header.size * 4u);
3401  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3402  CheckBytesWrittenMatchesExpectedSize(
3403      next_cmd, sizeof(cmd) +
3404      RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
3405  // TODO(gman): Check that ids were inserted;
3406}
3407
3408TEST_F(GLES2FormatTest, DeleteQueriesEXT) {
3409  cmds::DeleteQueriesEXT& cmd = *GetBufferAs<cmds::DeleteQueriesEXT>();
3410  void* next_cmd = cmd.Set(
3411      &cmd,
3412      static_cast<GLsizei>(11),
3413      static_cast<uint32>(12),
3414      static_cast<uint32>(13));
3415  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXT::kCmdId),
3416            cmd.header.command);
3417  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3418  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3419  EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
3420  EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
3421  CheckBytesWrittenMatchesExpectedSize(
3422      next_cmd, sizeof(cmd));
3423}
3424
3425TEST_F(GLES2FormatTest, DeleteQueriesEXTImmediate) {
3426  static GLuint ids[] = { 12, 23, 34, };
3427  cmds::DeleteQueriesEXTImmediate& cmd =
3428      *GetBufferAs<cmds::DeleteQueriesEXTImmediate>();
3429  void* next_cmd = cmd.Set(
3430      &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3431  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXTImmediate::kCmdId),
3432            cmd.header.command);
3433  EXPECT_EQ(sizeof(cmd) +
3434            RoundSizeToMultipleOfEntries(cmd.n * 4u),
3435            cmd.header.size * 4u);
3436  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3437  CheckBytesWrittenMatchesExpectedSize(
3438      next_cmd, sizeof(cmd) +
3439      RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
3440  // TODO(gman): Check that ids were inserted;
3441}
3442
3443TEST_F(GLES2FormatTest, BeginQueryEXT) {
3444  cmds::BeginQueryEXT& cmd = *GetBufferAs<cmds::BeginQueryEXT>();
3445  void* next_cmd = cmd.Set(
3446      &cmd,
3447      static_cast<GLenum>(11),
3448      static_cast<GLuint>(12),
3449      static_cast<uint32>(13),
3450      static_cast<uint32>(14));
3451  EXPECT_EQ(static_cast<uint32>(cmds::BeginQueryEXT::kCmdId),
3452            cmd.header.command);
3453  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3454  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3455  EXPECT_EQ(static_cast<GLuint>(12), cmd.id);
3456  EXPECT_EQ(static_cast<uint32>(13), cmd.sync_data_shm_id);
3457  EXPECT_EQ(static_cast<uint32>(14), cmd.sync_data_shm_offset);
3458  CheckBytesWrittenMatchesExpectedSize(
3459      next_cmd, sizeof(cmd));
3460}
3461
3462TEST_F(GLES2FormatTest, EndQueryEXT) {
3463  cmds::EndQueryEXT& cmd = *GetBufferAs<cmds::EndQueryEXT>();
3464  void* next_cmd = cmd.Set(
3465      &cmd,
3466      static_cast<GLenum>(11),
3467      static_cast<GLuint>(12));
3468  EXPECT_EQ(static_cast<uint32>(cmds::EndQueryEXT::kCmdId),
3469            cmd.header.command);
3470  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3471  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3472  EXPECT_EQ(static_cast<GLuint>(12), cmd.submit_count);
3473  CheckBytesWrittenMatchesExpectedSize(
3474      next_cmd, sizeof(cmd));
3475}
3476
3477TEST_F(GLES2FormatTest, InsertEventMarkerEXT) {
3478  cmds::InsertEventMarkerEXT& cmd = *GetBufferAs<cmds::InsertEventMarkerEXT>();
3479  void* next_cmd = cmd.Set(
3480      &cmd,
3481      static_cast<GLuint>(11));
3482  EXPECT_EQ(static_cast<uint32>(cmds::InsertEventMarkerEXT::kCmdId),
3483            cmd.header.command);
3484  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3485  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3486  CheckBytesWrittenMatchesExpectedSize(
3487      next_cmd, sizeof(cmd));
3488}
3489
3490TEST_F(GLES2FormatTest, PushGroupMarkerEXT) {
3491  cmds::PushGroupMarkerEXT& cmd = *GetBufferAs<cmds::PushGroupMarkerEXT>();
3492  void* next_cmd = cmd.Set(
3493      &cmd,
3494      static_cast<GLuint>(11));
3495  EXPECT_EQ(static_cast<uint32>(cmds::PushGroupMarkerEXT::kCmdId),
3496            cmd.header.command);
3497  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3498  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3499  CheckBytesWrittenMatchesExpectedSize(
3500      next_cmd, sizeof(cmd));
3501}
3502
3503TEST_F(GLES2FormatTest, PopGroupMarkerEXT) {
3504  cmds::PopGroupMarkerEXT& cmd = *GetBufferAs<cmds::PopGroupMarkerEXT>();
3505  void* next_cmd = cmd.Set(
3506      &cmd);
3507  EXPECT_EQ(static_cast<uint32>(cmds::PopGroupMarkerEXT::kCmdId),
3508            cmd.header.command);
3509  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3510  CheckBytesWrittenMatchesExpectedSize(
3511      next_cmd, sizeof(cmd));
3512}
3513
3514TEST_F(GLES2FormatTest, GenVertexArraysOES) {
3515  cmds::GenVertexArraysOES& cmd = *GetBufferAs<cmds::GenVertexArraysOES>();
3516  void* next_cmd = cmd.Set(
3517      &cmd,
3518      static_cast<GLsizei>(11),
3519      static_cast<uint32>(12),
3520      static_cast<uint32>(13));
3521  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOES::kCmdId),
3522            cmd.header.command);
3523  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3524  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3525  EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
3526  EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
3527  CheckBytesWrittenMatchesExpectedSize(
3528      next_cmd, sizeof(cmd));
3529}
3530
3531TEST_F(GLES2FormatTest, GenVertexArraysOESImmediate) {
3532  static GLuint ids[] = { 12, 23, 34, };
3533  cmds::GenVertexArraysOESImmediate& cmd =
3534      *GetBufferAs<cmds::GenVertexArraysOESImmediate>();
3535  void* next_cmd = cmd.Set(
3536      &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3537  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOESImmediate::kCmdId),
3538            cmd.header.command);
3539  EXPECT_EQ(sizeof(cmd) +
3540            RoundSizeToMultipleOfEntries(cmd.n * 4u),
3541            cmd.header.size * 4u);
3542  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3543  CheckBytesWrittenMatchesExpectedSize(
3544      next_cmd, sizeof(cmd) +
3545      RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
3546  // TODO(gman): Check that ids were inserted;
3547}
3548
3549TEST_F(GLES2FormatTest, DeleteVertexArraysOES) {
3550  cmds::DeleteVertexArraysOES& cmd =
3551      *GetBufferAs<cmds::DeleteVertexArraysOES>();
3552  void* next_cmd = cmd.Set(
3553      &cmd,
3554      static_cast<GLsizei>(11),
3555      static_cast<uint32>(12),
3556      static_cast<uint32>(13));
3557  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOES::kCmdId),
3558            cmd.header.command);
3559  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3560  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3561  EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
3562  EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
3563  CheckBytesWrittenMatchesExpectedSize(
3564      next_cmd, sizeof(cmd));
3565}
3566
3567TEST_F(GLES2FormatTest, DeleteVertexArraysOESImmediate) {
3568  static GLuint ids[] = { 12, 23, 34, };
3569  cmds::DeleteVertexArraysOESImmediate& cmd =
3570      *GetBufferAs<cmds::DeleteVertexArraysOESImmediate>();
3571  void* next_cmd = cmd.Set(
3572      &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3573  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOESImmediate::kCmdId),
3574            cmd.header.command);
3575  EXPECT_EQ(sizeof(cmd) +
3576            RoundSizeToMultipleOfEntries(cmd.n * 4u),
3577            cmd.header.size * 4u);
3578  EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3579  CheckBytesWrittenMatchesExpectedSize(
3580      next_cmd, sizeof(cmd) +
3581      RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
3582  // TODO(gman): Check that ids were inserted;
3583}
3584
3585TEST_F(GLES2FormatTest, IsVertexArrayOES) {
3586  cmds::IsVertexArrayOES& cmd = *GetBufferAs<cmds::IsVertexArrayOES>();
3587  void* next_cmd = cmd.Set(
3588      &cmd,
3589      static_cast<GLuint>(11),
3590      static_cast<uint32>(12),
3591      static_cast<uint32>(13));
3592  EXPECT_EQ(static_cast<uint32>(cmds::IsVertexArrayOES::kCmdId),
3593            cmd.header.command);
3594  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3595  EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
3596  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3597  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3598  CheckBytesWrittenMatchesExpectedSize(
3599      next_cmd, sizeof(cmd));
3600}
3601
3602TEST_F(GLES2FormatTest, BindVertexArrayOES) {
3603  cmds::BindVertexArrayOES& cmd = *GetBufferAs<cmds::BindVertexArrayOES>();
3604  void* next_cmd = cmd.Set(
3605      &cmd,
3606      static_cast<GLuint>(11));
3607  EXPECT_EQ(static_cast<uint32>(cmds::BindVertexArrayOES::kCmdId),
3608            cmd.header.command);
3609  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3610  EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
3611  CheckBytesWrittenMatchesExpectedSize(
3612      next_cmd, sizeof(cmd));
3613}
3614
3615TEST_F(GLES2FormatTest, SwapBuffers) {
3616  cmds::SwapBuffers& cmd = *GetBufferAs<cmds::SwapBuffers>();
3617  void* next_cmd = cmd.Set(
3618      &cmd);
3619  EXPECT_EQ(static_cast<uint32>(cmds::SwapBuffers::kCmdId),
3620            cmd.header.command);
3621  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3622  CheckBytesWrittenMatchesExpectedSize(
3623      next_cmd, sizeof(cmd));
3624}
3625
3626TEST_F(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
3627  cmds::GetMaxValueInBufferCHROMIUM& cmd =
3628      *GetBufferAs<cmds::GetMaxValueInBufferCHROMIUM>();
3629  void* next_cmd = cmd.Set(
3630      &cmd,
3631      static_cast<GLuint>(11),
3632      static_cast<GLsizei>(12),
3633      static_cast<GLenum>(13),
3634      static_cast<GLuint>(14),
3635      static_cast<uint32>(15),
3636      static_cast<uint32>(16));
3637  EXPECT_EQ(static_cast<uint32>(cmds::GetMaxValueInBufferCHROMIUM::kCmdId),
3638            cmd.header.command);
3639  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3640  EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer_id);
3641  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
3642  EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3643  EXPECT_EQ(static_cast<GLuint>(14), cmd.offset);
3644  EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_id);
3645  EXPECT_EQ(static_cast<uint32>(16), cmd.result_shm_offset);
3646  CheckBytesWrittenMatchesExpectedSize(
3647      next_cmd, sizeof(cmd));
3648}
3649
3650TEST_F(GLES2FormatTest, GenSharedIdsCHROMIUM) {
3651  cmds::GenSharedIdsCHROMIUM& cmd = *GetBufferAs<cmds::GenSharedIdsCHROMIUM>();
3652  void* next_cmd = cmd.Set(
3653      &cmd,
3654      static_cast<GLuint>(11),
3655      static_cast<GLuint>(12),
3656      static_cast<GLsizei>(13),
3657      static_cast<uint32>(14),
3658      static_cast<uint32>(15));
3659  EXPECT_EQ(static_cast<uint32>(cmds::GenSharedIdsCHROMIUM::kCmdId),
3660            cmd.header.command);
3661  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3662  EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3663  EXPECT_EQ(static_cast<GLuint>(12), cmd.id_offset);
3664  EXPECT_EQ(static_cast<GLsizei>(13), cmd.n);
3665  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_id);
3666  EXPECT_EQ(static_cast<uint32>(15), cmd.ids_shm_offset);
3667  CheckBytesWrittenMatchesExpectedSize(
3668      next_cmd, sizeof(cmd));
3669}
3670
3671TEST_F(GLES2FormatTest, DeleteSharedIdsCHROMIUM) {
3672  cmds::DeleteSharedIdsCHROMIUM& cmd =
3673      *GetBufferAs<cmds::DeleteSharedIdsCHROMIUM>();
3674  void* next_cmd = cmd.Set(
3675      &cmd,
3676      static_cast<GLuint>(11),
3677      static_cast<GLsizei>(12),
3678      static_cast<uint32>(13),
3679      static_cast<uint32>(14));
3680  EXPECT_EQ(static_cast<uint32>(cmds::DeleteSharedIdsCHROMIUM::kCmdId),
3681            cmd.header.command);
3682  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3683  EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3684  EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
3685  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
3686  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
3687  CheckBytesWrittenMatchesExpectedSize(
3688      next_cmd, sizeof(cmd));
3689}
3690
3691TEST_F(GLES2FormatTest, RegisterSharedIdsCHROMIUM) {
3692  cmds::RegisterSharedIdsCHROMIUM& cmd =
3693      *GetBufferAs<cmds::RegisterSharedIdsCHROMIUM>();
3694  void* next_cmd = cmd.Set(
3695      &cmd,
3696      static_cast<GLuint>(11),
3697      static_cast<GLsizei>(12),
3698      static_cast<uint32>(13),
3699      static_cast<uint32>(14));
3700  EXPECT_EQ(static_cast<uint32>(cmds::RegisterSharedIdsCHROMIUM::kCmdId),
3701            cmd.header.command);
3702  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3703  EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3704  EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
3705  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
3706  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
3707  CheckBytesWrittenMatchesExpectedSize(
3708      next_cmd, sizeof(cmd));
3709}
3710
3711TEST_F(GLES2FormatTest, EnableFeatureCHROMIUM) {
3712  cmds::EnableFeatureCHROMIUM& cmd =
3713      *GetBufferAs<cmds::EnableFeatureCHROMIUM>();
3714  void* next_cmd = cmd.Set(
3715      &cmd,
3716      static_cast<GLuint>(11),
3717      static_cast<uint32>(12),
3718      static_cast<uint32>(13));
3719  EXPECT_EQ(static_cast<uint32>(cmds::EnableFeatureCHROMIUM::kCmdId),
3720            cmd.header.command);
3721  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3722  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3723  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3724  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3725  CheckBytesWrittenMatchesExpectedSize(
3726      next_cmd, sizeof(cmd));
3727}
3728
3729TEST_F(GLES2FormatTest, ResizeCHROMIUM) {
3730  cmds::ResizeCHROMIUM& cmd = *GetBufferAs<cmds::ResizeCHROMIUM>();
3731  void* next_cmd = cmd.Set(
3732      &cmd,
3733      static_cast<GLuint>(11),
3734      static_cast<GLuint>(12),
3735      static_cast<GLfloat>(13));
3736  EXPECT_EQ(static_cast<uint32>(cmds::ResizeCHROMIUM::kCmdId),
3737            cmd.header.command);
3738  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3739  EXPECT_EQ(static_cast<GLuint>(11), cmd.width);
3740  EXPECT_EQ(static_cast<GLuint>(12), cmd.height);
3741  EXPECT_EQ(static_cast<GLfloat>(13), cmd.scale_factor);
3742  CheckBytesWrittenMatchesExpectedSize(
3743      next_cmd, sizeof(cmd));
3744}
3745
3746TEST_F(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) {
3747  cmds::GetRequestableExtensionsCHROMIUM& cmd =
3748      *GetBufferAs<cmds::GetRequestableExtensionsCHROMIUM>();
3749  void* next_cmd = cmd.Set(
3750      &cmd,
3751      static_cast<uint32>(11));
3752  EXPECT_EQ(
3753      static_cast<uint32>(cmds::GetRequestableExtensionsCHROMIUM::kCmdId),
3754            cmd.header.command);
3755  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3756  EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
3757  CheckBytesWrittenMatchesExpectedSize(
3758      next_cmd, sizeof(cmd));
3759}
3760
3761TEST_F(GLES2FormatTest, RequestExtensionCHROMIUM) {
3762  cmds::RequestExtensionCHROMIUM& cmd =
3763      *GetBufferAs<cmds::RequestExtensionCHROMIUM>();
3764  void* next_cmd = cmd.Set(
3765      &cmd,
3766      static_cast<uint32>(11));
3767  EXPECT_EQ(static_cast<uint32>(cmds::RequestExtensionCHROMIUM::kCmdId),
3768            cmd.header.command);
3769  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3770  EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
3771  CheckBytesWrittenMatchesExpectedSize(
3772      next_cmd, sizeof(cmd));
3773}
3774
3775TEST_F(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
3776  cmds::GetMultipleIntegervCHROMIUM& cmd =
3777      *GetBufferAs<cmds::GetMultipleIntegervCHROMIUM>();
3778  void* next_cmd = cmd.Set(
3779      &cmd,
3780      static_cast<uint32>(11),
3781      static_cast<uint32>(12),
3782      static_cast<GLuint>(13),
3783      static_cast<uint32>(14),
3784      static_cast<uint32>(15),
3785      static_cast<GLsizeiptr>(16));
3786  EXPECT_EQ(static_cast<uint32>(cmds::GetMultipleIntegervCHROMIUM::kCmdId),
3787            cmd.header.command);
3788  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3789  EXPECT_EQ(static_cast<uint32>(11), cmd.pnames_shm_id);
3790  EXPECT_EQ(static_cast<uint32>(12), cmd.pnames_shm_offset);
3791  EXPECT_EQ(static_cast<GLuint>(13), cmd.count);
3792  EXPECT_EQ(static_cast<uint32>(14), cmd.results_shm_id);
3793  EXPECT_EQ(static_cast<uint32>(15), cmd.results_shm_offset);
3794  EXPECT_EQ(static_cast<GLsizeiptr>(16), cmd.size);
3795  CheckBytesWrittenMatchesExpectedSize(
3796      next_cmd, sizeof(cmd));
3797}
3798
3799TEST_F(GLES2FormatTest, GetProgramInfoCHROMIUM) {
3800  cmds::GetProgramInfoCHROMIUM& cmd =
3801      *GetBufferAs<cmds::GetProgramInfoCHROMIUM>();
3802  void* next_cmd = cmd.Set(
3803      &cmd,
3804      static_cast<GLuint>(11),
3805      static_cast<uint32>(12));
3806  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramInfoCHROMIUM::kCmdId),
3807            cmd.header.command);
3808  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3809  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
3810  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
3811  CheckBytesWrittenMatchesExpectedSize(
3812      next_cmd, sizeof(cmd));
3813}
3814
3815TEST_F(GLES2FormatTest, CreateStreamTextureCHROMIUM) {
3816  cmds::CreateStreamTextureCHROMIUM& cmd =
3817      *GetBufferAs<cmds::CreateStreamTextureCHROMIUM>();
3818  void* next_cmd = cmd.Set(
3819      &cmd,
3820      static_cast<GLuint>(11),
3821      static_cast<uint32>(12),
3822      static_cast<uint32>(13));
3823  EXPECT_EQ(static_cast<uint32>(cmds::CreateStreamTextureCHROMIUM::kCmdId),
3824            cmd.header.command);
3825  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3826  EXPECT_EQ(static_cast<GLuint>(11), cmd.client_id);
3827  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3828  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3829  CheckBytesWrittenMatchesExpectedSize(
3830      next_cmd, sizeof(cmd));
3831}
3832
3833TEST_F(GLES2FormatTest, DestroyStreamTextureCHROMIUM) {
3834  cmds::DestroyStreamTextureCHROMIUM& cmd =
3835      *GetBufferAs<cmds::DestroyStreamTextureCHROMIUM>();
3836  void* next_cmd = cmd.Set(
3837      &cmd,
3838      static_cast<GLuint>(11));
3839  EXPECT_EQ(static_cast<uint32>(cmds::DestroyStreamTextureCHROMIUM::kCmdId),
3840            cmd.header.command);
3841  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3842  EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
3843  CheckBytesWrittenMatchesExpectedSize(
3844      next_cmd, sizeof(cmd));
3845}
3846
3847TEST_F(GLES2FormatTest, GetTranslatedShaderSourceANGLE) {
3848  cmds::GetTranslatedShaderSourceANGLE& cmd =
3849      *GetBufferAs<cmds::GetTranslatedShaderSourceANGLE>();
3850  void* next_cmd = cmd.Set(
3851      &cmd,
3852      static_cast<GLuint>(11),
3853      static_cast<uint32>(12));
3854  EXPECT_EQ(static_cast<uint32>(cmds::GetTranslatedShaderSourceANGLE::kCmdId),
3855            cmd.header.command);
3856  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3857  EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
3858  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
3859  CheckBytesWrittenMatchesExpectedSize(
3860      next_cmd, sizeof(cmd));
3861}
3862
3863TEST_F(GLES2FormatTest, PostSubBufferCHROMIUM) {
3864  cmds::PostSubBufferCHROMIUM& cmd =
3865      *GetBufferAs<cmds::PostSubBufferCHROMIUM>();
3866  void* next_cmd = cmd.Set(
3867      &cmd,
3868      static_cast<GLint>(11),
3869      static_cast<GLint>(12),
3870      static_cast<GLint>(13),
3871      static_cast<GLint>(14));
3872  EXPECT_EQ(static_cast<uint32>(cmds::PostSubBufferCHROMIUM::kCmdId),
3873            cmd.header.command);
3874  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3875  EXPECT_EQ(static_cast<GLint>(11), cmd.x);
3876  EXPECT_EQ(static_cast<GLint>(12), cmd.y);
3877  EXPECT_EQ(static_cast<GLint>(13), cmd.width);
3878  EXPECT_EQ(static_cast<GLint>(14), cmd.height);
3879  CheckBytesWrittenMatchesExpectedSize(
3880      next_cmd, sizeof(cmd));
3881}
3882
3883TEST_F(GLES2FormatTest, TexImageIOSurface2DCHROMIUM) {
3884  cmds::TexImageIOSurface2DCHROMIUM& cmd =
3885      *GetBufferAs<cmds::TexImageIOSurface2DCHROMIUM>();
3886  void* next_cmd = cmd.Set(
3887      &cmd,
3888      static_cast<GLenum>(11),
3889      static_cast<GLsizei>(12),
3890      static_cast<GLsizei>(13),
3891      static_cast<GLuint>(14),
3892      static_cast<GLuint>(15));
3893  EXPECT_EQ(static_cast<uint32>(cmds::TexImageIOSurface2DCHROMIUM::kCmdId),
3894            cmd.header.command);
3895  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3896  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3897  EXPECT_EQ(static_cast<GLsizei>(12), cmd.width);
3898  EXPECT_EQ(static_cast<GLsizei>(13), cmd.height);
3899  EXPECT_EQ(static_cast<GLuint>(14), cmd.ioSurfaceId);
3900  EXPECT_EQ(static_cast<GLuint>(15), cmd.plane);
3901  CheckBytesWrittenMatchesExpectedSize(
3902      next_cmd, sizeof(cmd));
3903}
3904
3905TEST_F(GLES2FormatTest, CopyTextureCHROMIUM) {
3906  cmds::CopyTextureCHROMIUM& cmd = *GetBufferAs<cmds::CopyTextureCHROMIUM>();
3907  void* next_cmd = cmd.Set(
3908      &cmd,
3909      static_cast<GLenum>(11),
3910      static_cast<GLenum>(12),
3911      static_cast<GLenum>(13),
3912      static_cast<GLint>(14),
3913      static_cast<GLint>(15),
3914      static_cast<GLenum>(16));
3915  EXPECT_EQ(static_cast<uint32>(cmds::CopyTextureCHROMIUM::kCmdId),
3916            cmd.header.command);
3917  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3918  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3919  EXPECT_EQ(static_cast<GLenum>(12), cmd.source_id);
3920  EXPECT_EQ(static_cast<GLenum>(13), cmd.dest_id);
3921  EXPECT_EQ(static_cast<GLint>(14), cmd.level);
3922  EXPECT_EQ(static_cast<GLint>(15), cmd.internalformat);
3923  EXPECT_EQ(static_cast<GLenum>(16), cmd.dest_type);
3924  CheckBytesWrittenMatchesExpectedSize(
3925      next_cmd, sizeof(cmd));
3926}
3927
3928TEST_F(GLES2FormatTest, DrawArraysInstancedANGLE) {
3929  cmds::DrawArraysInstancedANGLE& cmd =
3930      *GetBufferAs<cmds::DrawArraysInstancedANGLE>();
3931  void* next_cmd = cmd.Set(
3932      &cmd,
3933      static_cast<GLenum>(11),
3934      static_cast<GLint>(12),
3935      static_cast<GLsizei>(13),
3936      static_cast<GLsizei>(14));
3937  EXPECT_EQ(static_cast<uint32>(cmds::DrawArraysInstancedANGLE::kCmdId),
3938            cmd.header.command);
3939  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3940  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
3941  EXPECT_EQ(static_cast<GLint>(12), cmd.first);
3942  EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
3943  EXPECT_EQ(static_cast<GLsizei>(14), cmd.primcount);
3944  CheckBytesWrittenMatchesExpectedSize(
3945      next_cmd, sizeof(cmd));
3946}
3947
3948TEST_F(GLES2FormatTest, DrawElementsInstancedANGLE) {
3949  cmds::DrawElementsInstancedANGLE& cmd =
3950      *GetBufferAs<cmds::DrawElementsInstancedANGLE>();
3951  void* next_cmd = cmd.Set(
3952      &cmd,
3953      static_cast<GLenum>(11),
3954      static_cast<GLsizei>(12),
3955      static_cast<GLenum>(13),
3956      static_cast<GLuint>(14),
3957      static_cast<GLsizei>(15));
3958  EXPECT_EQ(static_cast<uint32>(cmds::DrawElementsInstancedANGLE::kCmdId),
3959            cmd.header.command);
3960  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3961  EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
3962  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
3963  EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3964  EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
3965  EXPECT_EQ(static_cast<GLsizei>(15), cmd.primcount);
3966  CheckBytesWrittenMatchesExpectedSize(
3967      next_cmd, sizeof(cmd));
3968}
3969
3970TEST_F(GLES2FormatTest, VertexAttribDivisorANGLE) {
3971  cmds::VertexAttribDivisorANGLE& cmd =
3972      *GetBufferAs<cmds::VertexAttribDivisorANGLE>();
3973  void* next_cmd = cmd.Set(
3974      &cmd,
3975      static_cast<GLuint>(11),
3976      static_cast<GLuint>(12));
3977  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribDivisorANGLE::kCmdId),
3978            cmd.header.command);
3979  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3980  EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
3981  EXPECT_EQ(static_cast<GLuint>(12), cmd.divisor);
3982  CheckBytesWrittenMatchesExpectedSize(
3983      next_cmd, sizeof(cmd));
3984}
3985
3986TEST_F(GLES2FormatTest, GenMailboxCHROMIUM) {
3987  cmds::GenMailboxCHROMIUM& cmd = *GetBufferAs<cmds::GenMailboxCHROMIUM>();
3988  void* next_cmd = cmd.Set(
3989      &cmd,
3990      static_cast<GLuint>(11));
3991  EXPECT_EQ(static_cast<uint32>(cmds::GenMailboxCHROMIUM::kCmdId),
3992            cmd.header.command);
3993  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3994  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3995  CheckBytesWrittenMatchesExpectedSize(
3996      next_cmd, sizeof(cmd));
3997}
3998
3999TEST_F(GLES2FormatTest, ProduceTextureCHROMIUM) {
4000  cmds::ProduceTextureCHROMIUM& cmd =
4001      *GetBufferAs<cmds::ProduceTextureCHROMIUM>();
4002  void* next_cmd = cmd.Set(
4003      &cmd,
4004      static_cast<GLenum>(11),
4005      static_cast<uint32>(12),
4006      static_cast<uint32>(13));
4007  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUM::kCmdId),
4008            cmd.header.command);
4009  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4010  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4011  EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
4012  EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
4013  CheckBytesWrittenMatchesExpectedSize(
4014      next_cmd, sizeof(cmd));
4015}
4016
4017TEST_F(GLES2FormatTest, ProduceTextureCHROMIUMImmediate) {
4018  const int kSomeBaseValueToTestWith = 51;
4019  static GLbyte data[] = {
4020    static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
4021    static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
4022    static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
4023    static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
4024    static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
4025    static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
4026    static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
4027    static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
4028    static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
4029    static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
4030    static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
4031    static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
4032    static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
4033    static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
4034    static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
4035    static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
4036    static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
4037    static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
4038    static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
4039    static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
4040    static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
4041    static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
4042    static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
4043    static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
4044    static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
4045    static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
4046    static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
4047    static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
4048    static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
4049    static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
4050    static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
4051    static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
4052    static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
4053    static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
4054    static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
4055    static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
4056    static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
4057    static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
4058    static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
4059    static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
4060    static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
4061    static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
4062    static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
4063    static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
4064    static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
4065    static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
4066    static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
4067    static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
4068    static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
4069    static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
4070    static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
4071    static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
4072    static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
4073    static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
4074    static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
4075    static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
4076    static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
4077    static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
4078    static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
4079    static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
4080    static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
4081    static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
4082    static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
4083    static_cast<GLbyte>(kSomeBaseValueToTestWith + 63),
4084  };
4085  cmds::ProduceTextureCHROMIUMImmediate& cmd =
4086      *GetBufferAs<cmds::ProduceTextureCHROMIUMImmediate>();
4087  void* next_cmd = cmd.Set(
4088      &cmd,
4089      static_cast<GLenum>(11),
4090      data);
4091  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUMImmediate::kCmdId),
4092            cmd.header.command);
4093  EXPECT_EQ(sizeof(cmd) +
4094            RoundSizeToMultipleOfEntries(sizeof(data)),
4095            cmd.header.size * 4u);
4096  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4097  CheckBytesWrittenMatchesExpectedSize(
4098      next_cmd, sizeof(cmd) +
4099      RoundSizeToMultipleOfEntries(sizeof(data)));
4100  // TODO(gman): Check that data was inserted;
4101}
4102
4103TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUM) {
4104  cmds::ConsumeTextureCHROMIUM& cmd =
4105      *GetBufferAs<cmds::ConsumeTextureCHROMIUM>();
4106  void* next_cmd = cmd.Set(
4107      &cmd,
4108      static_cast<GLenum>(11),
4109      static_cast<uint32>(12),
4110      static_cast<uint32>(13));
4111  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUM::kCmdId),
4112            cmd.header.command);
4113  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4114  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4115  EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
4116  EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
4117  CheckBytesWrittenMatchesExpectedSize(
4118      next_cmd, sizeof(cmd));
4119}
4120
4121TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUMImmediate) {
4122  const int kSomeBaseValueToTestWith = 51;
4123  static GLbyte data[] = {
4124    static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
4125    static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
4126    static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
4127    static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
4128    static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
4129    static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
4130    static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
4131    static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
4132    static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
4133    static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
4134    static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
4135    static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
4136    static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
4137    static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
4138    static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
4139    static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
4140    static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
4141    static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
4142    static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
4143    static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
4144    static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
4145    static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
4146    static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
4147    static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
4148    static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
4149    static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
4150    static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
4151    static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
4152    static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
4153    static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
4154    static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
4155    static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
4156    static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
4157    static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
4158    static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
4159    static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
4160    static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
4161    static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
4162    static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
4163    static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
4164    static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
4165    static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
4166    static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
4167    static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
4168    static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
4169    static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
4170    static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
4171    static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
4172    static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
4173    static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
4174    static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
4175    static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
4176    static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
4177    static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
4178    static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
4179    static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
4180    static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
4181    static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
4182    static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
4183    static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
4184    static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
4185    static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
4186    static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
4187    static_cast<GLbyte>(kSomeBaseValueToTestWith + 63),
4188  };
4189  cmds::ConsumeTextureCHROMIUMImmediate& cmd =
4190      *GetBufferAs<cmds::ConsumeTextureCHROMIUMImmediate>();
4191  void* next_cmd = cmd.Set(
4192      &cmd,
4193      static_cast<GLenum>(11),
4194      data);
4195  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUMImmediate::kCmdId),
4196            cmd.header.command);
4197  EXPECT_EQ(sizeof(cmd) +
4198            RoundSizeToMultipleOfEntries(sizeof(data)),
4199            cmd.header.size * 4u);
4200  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4201  CheckBytesWrittenMatchesExpectedSize(
4202      next_cmd, sizeof(cmd) +
4203      RoundSizeToMultipleOfEntries(sizeof(data)));
4204  // TODO(gman): Check that data was inserted;
4205}
4206
4207TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUM) {
4208  cmds::BindUniformLocationCHROMIUM& cmd =
4209      *GetBufferAs<cmds::BindUniformLocationCHROMIUM>();
4210  void* next_cmd = cmd.Set(
4211      &cmd,
4212      static_cast<GLuint>(11),
4213      static_cast<GLint>(12),
4214      static_cast<uint32>(13),
4215      static_cast<uint32>(14),
4216      static_cast<uint32>(15));
4217  EXPECT_EQ(static_cast<uint32>(cmds::BindUniformLocationCHROMIUM::kCmdId),
4218            cmd.header.command);
4219  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4220  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
4221  EXPECT_EQ(static_cast<GLint>(12), cmd.location);
4222  EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
4223  EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
4224  EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
4225  CheckBytesWrittenMatchesExpectedSize(
4226      next_cmd, sizeof(cmd));
4227}
4228
4229
4230TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUMImmediate) {
4231  cmds::BindUniformLocationCHROMIUMImmediate& cmd =
4232      *GetBufferAs<cmds::BindUniformLocationCHROMIUMImmediate>();
4233  static const char* const test_str = "test string";
4234  void* next_cmd = cmd.Set(
4235      &cmd,
4236      static_cast<GLuint>(11),
4237      static_cast<GLint>(12),
4238      test_str,
4239      strlen(test_str));
4240  EXPECT_EQ(
4241      static_cast<uint32>(cmds::BindUniformLocationCHROMIUMImmediate::kCmdId),
4242            cmd.header.command);
4243  EXPECT_EQ(sizeof(cmd) +
4244            RoundSizeToMultipleOfEntries(strlen(test_str)),
4245            cmd.header.size * 4u);
4246  EXPECT_EQ(static_cast<char*>(next_cmd),
4247            reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
4248                RoundSizeToMultipleOfEntries(strlen(test_str)));
4249  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
4250  EXPECT_EQ(static_cast<GLint>(12), cmd.location);
4251  EXPECT_EQ(static_cast<uint32>(strlen(test_str)), cmd.data_size);
4252  EXPECT_EQ(0, memcmp(test_str, ImmediateDataAddress(&cmd), strlen(test_str)));
4253  CheckBytesWritten(
4254      next_cmd,
4255      sizeof(cmd) + RoundSizeToMultipleOfEntries(strlen(test_str)),
4256      sizeof(cmd) + strlen(test_str));
4257}
4258
4259TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUMBucket) {
4260  cmds::BindUniformLocationCHROMIUMBucket& cmd =
4261      *GetBufferAs<cmds::BindUniformLocationCHROMIUMBucket>();
4262  void* next_cmd = cmd.Set(
4263      &cmd,
4264      static_cast<GLuint>(11),
4265      static_cast<GLint>(12),
4266      static_cast<uint32>(13));
4267  EXPECT_EQ(
4268      static_cast<uint32>(cmds::BindUniformLocationCHROMIUMBucket::kCmdId),
4269            cmd.header.command);
4270  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4271  EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
4272  EXPECT_EQ(static_cast<GLint>(12), cmd.location);
4273  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
4274  CheckBytesWrittenMatchesExpectedSize(
4275      next_cmd, sizeof(cmd));
4276}
4277
4278TEST_F(GLES2FormatTest, BindTexImage2DCHROMIUM) {
4279  cmds::BindTexImage2DCHROMIUM& cmd =
4280      *GetBufferAs<cmds::BindTexImage2DCHROMIUM>();
4281  void* next_cmd = cmd.Set(
4282      &cmd,
4283      static_cast<GLenum>(11),
4284      static_cast<GLint>(12));
4285  EXPECT_EQ(static_cast<uint32>(cmds::BindTexImage2DCHROMIUM::kCmdId),
4286            cmd.header.command);
4287  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4288  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4289  EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
4290  CheckBytesWrittenMatchesExpectedSize(
4291      next_cmd, sizeof(cmd));
4292}
4293
4294TEST_F(GLES2FormatTest, ReleaseTexImage2DCHROMIUM) {
4295  cmds::ReleaseTexImage2DCHROMIUM& cmd =
4296      *GetBufferAs<cmds::ReleaseTexImage2DCHROMIUM>();
4297  void* next_cmd = cmd.Set(
4298      &cmd,
4299      static_cast<GLenum>(11),
4300      static_cast<GLint>(12));
4301  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseTexImage2DCHROMIUM::kCmdId),
4302            cmd.header.command);
4303  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4304  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4305  EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
4306  CheckBytesWrittenMatchesExpectedSize(
4307      next_cmd, sizeof(cmd));
4308}
4309
4310TEST_F(GLES2FormatTest, TraceBeginCHROMIUM) {
4311  cmds::TraceBeginCHROMIUM& cmd = *GetBufferAs<cmds::TraceBeginCHROMIUM>();
4312  void* next_cmd = cmd.Set(
4313      &cmd,
4314      static_cast<GLuint>(11));
4315  EXPECT_EQ(static_cast<uint32>(cmds::TraceBeginCHROMIUM::kCmdId),
4316            cmd.header.command);
4317  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4318  EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
4319  CheckBytesWrittenMatchesExpectedSize(
4320      next_cmd, sizeof(cmd));
4321}
4322
4323TEST_F(GLES2FormatTest, TraceEndCHROMIUM) {
4324  cmds::TraceEndCHROMIUM& cmd = *GetBufferAs<cmds::TraceEndCHROMIUM>();
4325  void* next_cmd = cmd.Set(
4326      &cmd);
4327  EXPECT_EQ(static_cast<uint32>(cmds::TraceEndCHROMIUM::kCmdId),
4328            cmd.header.command);
4329  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4330  CheckBytesWrittenMatchesExpectedSize(
4331      next_cmd, sizeof(cmd));
4332}
4333
4334TEST_F(GLES2FormatTest, AsyncTexSubImage2DCHROMIUM) {
4335  cmds::AsyncTexSubImage2DCHROMIUM& cmd =
4336      *GetBufferAs<cmds::AsyncTexSubImage2DCHROMIUM>();
4337  void* next_cmd = cmd.Set(
4338      &cmd,
4339      static_cast<GLenum>(11),
4340      static_cast<GLint>(12),
4341      static_cast<GLint>(13),
4342      static_cast<GLint>(14),
4343      static_cast<GLsizei>(15),
4344      static_cast<GLsizei>(16),
4345      static_cast<GLenum>(17),
4346      static_cast<GLenum>(18),
4347      static_cast<uint32>(19),
4348      static_cast<uint32>(20));
4349  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexSubImage2DCHROMIUM::kCmdId),
4350            cmd.header.command);
4351  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4352  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4353  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
4354  EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
4355  EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
4356  EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
4357  EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
4358  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
4359  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
4360  EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
4361  EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
4362  CheckBytesWrittenMatchesExpectedSize(
4363      next_cmd, sizeof(cmd));
4364}
4365
4366TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
4367  cmds::AsyncTexImage2DCHROMIUM& cmd =
4368      *GetBufferAs<cmds::AsyncTexImage2DCHROMIUM>();
4369  void* next_cmd = cmd.Set(
4370      &cmd,
4371      static_cast<GLenum>(11),
4372      static_cast<GLint>(12),
4373      static_cast<GLint>(13),
4374      static_cast<GLsizei>(14),
4375      static_cast<GLsizei>(15),
4376      static_cast<GLint>(16),
4377      static_cast<GLenum>(17),
4378      static_cast<GLenum>(18),
4379      static_cast<uint32>(19),
4380      static_cast<uint32>(20));
4381  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexImage2DCHROMIUM::kCmdId),
4382            cmd.header.command);
4383  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4384  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4385  EXPECT_EQ(static_cast<GLint>(12), cmd.level);
4386  EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
4387  EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
4388  EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
4389  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
4390  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
4391  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
4392  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
4393  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
4394  CheckBytesWrittenMatchesExpectedSize(
4395      next_cmd, sizeof(cmd));
4396}
4397
4398TEST_F(GLES2FormatTest, WaitAsyncTexImage2DCHROMIUM) {
4399  cmds::WaitAsyncTexImage2DCHROMIUM& cmd =
4400      *GetBufferAs<cmds::WaitAsyncTexImage2DCHROMIUM>();
4401  void* next_cmd = cmd.Set(
4402      &cmd,
4403      static_cast<GLenum>(11));
4404  EXPECT_EQ(static_cast<uint32>(cmds::WaitAsyncTexImage2DCHROMIUM::kCmdId),
4405            cmd.header.command);
4406  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4407  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4408  CheckBytesWrittenMatchesExpectedSize(
4409      next_cmd, sizeof(cmd));
4410}
4411
4412TEST_F(GLES2FormatTest, DiscardFramebufferEXT) {
4413  cmds::DiscardFramebufferEXT& cmd =
4414      *GetBufferAs<cmds::DiscardFramebufferEXT>();
4415  void* next_cmd = cmd.Set(
4416      &cmd,
4417      static_cast<GLenum>(11),
4418      static_cast<GLsizei>(12),
4419      static_cast<uint32>(13),
4420      static_cast<uint32>(14));
4421  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXT::kCmdId),
4422            cmd.header.command);
4423  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4424  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4425  EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
4426  EXPECT_EQ(static_cast<uint32>(13), cmd.attachments_shm_id);
4427  EXPECT_EQ(static_cast<uint32>(14), cmd.attachments_shm_offset);
4428  CheckBytesWrittenMatchesExpectedSize(
4429      next_cmd, sizeof(cmd));
4430}
4431
4432TEST_F(GLES2FormatTest, DiscardFramebufferEXTImmediate) {
4433  const int kSomeBaseValueToTestWith = 51;
4434  static GLenum data[] = {
4435    static_cast<GLenum>(kSomeBaseValueToTestWith + 0),
4436    static_cast<GLenum>(kSomeBaseValueToTestWith + 1),
4437  };
4438  cmds::DiscardFramebufferEXTImmediate& cmd =
4439      *GetBufferAs<cmds::DiscardFramebufferEXTImmediate>();
4440  const GLsizei kNumElements = 2;
4441  const size_t kExpectedCmdSize =
4442      sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
4443  void* next_cmd = cmd.Set(
4444      &cmd,
4445      static_cast<GLenum>(1),
4446      static_cast<GLsizei>(2),
4447      data);
4448  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXTImmediate::kCmdId),
4449            cmd.header.command);
4450  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
4451  EXPECT_EQ(static_cast<GLenum>(1), cmd.target);
4452  EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
4453  CheckBytesWrittenMatchesExpectedSize(
4454      next_cmd, sizeof(cmd) +
4455      RoundSizeToMultipleOfEntries(sizeof(data)));
4456  // TODO(gman): Check that data was inserted;
4457}
4458
4459TEST_F(GLES2FormatTest, LoseContextCHROMIUM) {
4460  cmds::LoseContextCHROMIUM& cmd = *GetBufferAs<cmds::LoseContextCHROMIUM>();
4461  void* next_cmd = cmd.Set(
4462      &cmd,
4463      static_cast<GLenum>(11),
4464      static_cast<GLenum>(12));
4465  EXPECT_EQ(static_cast<uint32>(cmds::LoseContextCHROMIUM::kCmdId),
4466            cmd.header.command);
4467  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4468  EXPECT_EQ(static_cast<GLenum>(11), cmd.current);
4469  EXPECT_EQ(static_cast<GLenum>(12), cmd.other);
4470  CheckBytesWrittenMatchesExpectedSize(
4471      next_cmd, sizeof(cmd));
4472}
4473
4474// TODO(gman): Write test for InsertSyncPointCHROMIUM
4475TEST_F(GLES2FormatTest, WaitSyncPointCHROMIUM) {
4476  cmds::WaitSyncPointCHROMIUM& cmd =
4477      *GetBufferAs<cmds::WaitSyncPointCHROMIUM>();
4478  void* next_cmd = cmd.Set(
4479      &cmd,
4480      static_cast<GLuint>(11));
4481  EXPECT_EQ(static_cast<uint32>(cmds::WaitSyncPointCHROMIUM::kCmdId),
4482            cmd.header.command);
4483  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4484  EXPECT_EQ(static_cast<GLuint>(11), cmd.sync_point);
4485  CheckBytesWrittenMatchesExpectedSize(
4486      next_cmd, sizeof(cmd));
4487}
4488
4489TEST_F(GLES2FormatTest, DrawBuffersEXT) {
4490  cmds::DrawBuffersEXT& cmd = *GetBufferAs<cmds::DrawBuffersEXT>();
4491  void* next_cmd = cmd.Set(
4492      &cmd,
4493      static_cast<GLsizei>(11),
4494      static_cast<uint32>(12),
4495      static_cast<uint32>(13));
4496  EXPECT_EQ(static_cast<uint32>(cmds::DrawBuffersEXT::kCmdId),
4497            cmd.header.command);
4498  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4499  EXPECT_EQ(static_cast<GLsizei>(11), cmd.count);
4500  EXPECT_EQ(static_cast<uint32>(12), cmd.bufs_shm_id);
4501  EXPECT_EQ(static_cast<uint32>(13), cmd.bufs_shm_offset);
4502  CheckBytesWrittenMatchesExpectedSize(
4503      next_cmd, sizeof(cmd));
4504}
4505
4506TEST_F(GLES2FormatTest, DrawBuffersEXTImmediate) {
4507  const int kSomeBaseValueToTestWith = 51;
4508  static GLenum data[] = {
4509    static_cast<GLenum>(kSomeBaseValueToTestWith + 0),
4510  };
4511  cmds::DrawBuffersEXTImmediate& cmd =
4512      *GetBufferAs<cmds::DrawBuffersEXTImmediate>();
4513  const GLsizei kNumElements = 1;
4514  const size_t kExpectedCmdSize =
4515      sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
4516  void* next_cmd = cmd.Set(
4517      &cmd,
4518      static_cast<GLsizei>(1),
4519      data);
4520  EXPECT_EQ(static_cast<uint32>(cmds::DrawBuffersEXTImmediate::kCmdId),
4521            cmd.header.command);
4522  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
4523  EXPECT_EQ(static_cast<GLsizei>(1), cmd.count);
4524  CheckBytesWrittenMatchesExpectedSize(
4525      next_cmd, sizeof(cmd) +
4526      RoundSizeToMultipleOfEntries(sizeof(data)));
4527  // TODO(gman): Check that data was inserted;
4528}
4529
4530#endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
4531
4532