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