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