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