src/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h

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