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