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