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