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