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