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