Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(913)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: gpu/command_buffer/common/gles2_cmd_format_test_autogen.h

Issue 488011: Another round of gcc fixes for GPU command buffers. (Closed)
Patch Set: Merge fixes Created 11 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « gpu/command_buffer/common/gles2_cmd_format_autogen.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
diff --git a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
index ed5455f33352737106cfb710213a072196fab94c..e00e8349f45e4edcd614295d6f53413c7e6a3059 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -4,29 +4,35 @@
// It is included by gles2_cmd_format_test.cc
TEST(GLES2FormatTest, ActiveTexture) {
- ActiveTexture cmd = { 0, };
+ ActiveTexture cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(ActiveTexture::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ActiveTexture::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.texture);
}
TEST(GLES2FormatTest, AttachShader) {
- AttachShader cmd = { 0, };
+ AttachShader cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLuint>(12));
- EXPECT_EQ(AttachShader::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(AttachShader::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
}
TEST(GLES2FormatTest, BindAttribLocation) {
- BindAttribLocation cmd = { 0, };
+ BindAttribLocation cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -34,8 +40,11 @@ TEST(GLES2FormatTest, BindAttribLocation) {
static_cast<uint32>(13),
static_cast<uint32>(14),
static_cast<uint32>(15));
- EXPECT_EQ(BindAttribLocation::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BindAttribLocation::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
@@ -53,73 +62,92 @@ TEST(GLES2FormatTest, BindAttribLocationImmediate) {
static_cast<GLuint>(11),
static_cast<GLuint>(12),
test_str);
- EXPECT_EQ(BindAttribLocationImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(BindAttribLocationImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) + // NOLINT
RoundSizeToMultipleOfEntries(strlen(test_str)),
- cmd.header.size * 4);
+ cmd.header.size * 4u);
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ strlen(test_str) + 1);
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
// TODO(gman): check that string got copied.
}
TEST(GLES2FormatTest, BindBuffer) {
- BindBuffer cmd = { 0, };
+ BindBuffer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLuint>(12));
- EXPECT_EQ(BindBuffer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BindBuffer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLuint>(12), cmd.buffer);
}
TEST(GLES2FormatTest, BindFramebuffer) {
- BindFramebuffer cmd = { 0, };
+ BindFramebuffer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLuint>(12));
- EXPECT_EQ(BindFramebuffer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BindFramebuffer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLuint>(12), cmd.framebuffer);
}
TEST(GLES2FormatTest, BindRenderbuffer) {
- BindRenderbuffer cmd = { 0, };
+ BindRenderbuffer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLuint>(12));
- EXPECT_EQ(BindRenderbuffer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BindRenderbuffer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLuint>(12), cmd.renderbuffer);
}
TEST(GLES2FormatTest, BindTexture) {
- BindTexture cmd = { 0, };
+ BindTexture cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLuint>(12));
- EXPECT_EQ(BindTexture::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BindTexture::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLuint>(12), cmd.texture);
}
TEST(GLES2FormatTest, BlendColor) {
- BlendColor cmd = { 0, };
+ BlendColor cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
static_cast<GLclampf>(12),
static_cast<GLclampf>(13),
static_cast<GLclampf>(14));
- EXPECT_EQ(BlendColor::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BlendColor::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
@@ -127,49 +155,61 @@ TEST(GLES2FormatTest, BlendColor) {
}
TEST(GLES2FormatTest, BlendEquation) {
- BlendEquation cmd = { 0, };
+ BlendEquation cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(BlendEquation::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BlendEquation::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
}
TEST(GLES2FormatTest, BlendEquationSeparate) {
- BlendEquationSeparate cmd = { 0, };
+ BlendEquationSeparate cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12));
- EXPECT_EQ(BlendEquationSeparate::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BlendEquationSeparate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.modeRGB);
EXPECT_EQ(static_cast<GLenum>(12), cmd.modeAlpha);
}
TEST(GLES2FormatTest, BlendFunc) {
- BlendFunc cmd = { 0, };
+ BlendFunc cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12));
- EXPECT_EQ(BlendFunc::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BlendFunc::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.sfactor);
EXPECT_EQ(static_cast<GLenum>(12), cmd.dfactor);
}
TEST(GLES2FormatTest, BlendFuncSeparate) {
- BlendFuncSeparate cmd = { 0, };
+ BlendFuncSeparate cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLenum>(13),
static_cast<GLenum>(14));
- EXPECT_EQ(BlendFuncSeparate::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BlendFuncSeparate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.srcRGB);
EXPECT_EQ(static_cast<GLenum>(12), cmd.dstRGB);
EXPECT_EQ(static_cast<GLenum>(13), cmd.srcAlpha);
@@ -177,7 +217,7 @@ TEST(GLES2FormatTest, BlendFuncSeparate) {
}
TEST(GLES2FormatTest, BufferData) {
- BufferData cmd = { 0, };
+ BufferData cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -185,8 +225,11 @@ TEST(GLES2FormatTest, BufferData) {
static_cast<uint32>(13),
static_cast<uint32>(14),
static_cast<GLenum>(15));
- EXPECT_EQ(BufferData::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BufferData::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLsizeiptr>(12), cmd.size);
EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id);
@@ -196,7 +239,7 @@ TEST(GLES2FormatTest, BufferData) {
// TODO(gman): Implement test for BufferDataImmediate
TEST(GLES2FormatTest, BufferSubData) {
- BufferSubData cmd = { 0, };
+ BufferSubData cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -204,8 +247,11 @@ TEST(GLES2FormatTest, BufferSubData) {
static_cast<GLsizeiptr>(13),
static_cast<uint32>(14),
static_cast<uint32>(15));
- EXPECT_EQ(BufferSubData::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(BufferSubData::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLintptr>(12), cmd.offset);
EXPECT_EQ(static_cast<GLsizeiptr>(13), cmd.size);
@@ -215,35 +261,44 @@ TEST(GLES2FormatTest, BufferSubData) {
// TODO(gman): Implement test for BufferSubDataImmediate
TEST(GLES2FormatTest, CheckFramebufferStatus) {
- CheckFramebufferStatus cmd = { 0, };
+ CheckFramebufferStatus cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(CheckFramebufferStatus::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CheckFramebufferStatus::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
}
TEST(GLES2FormatTest, Clear) {
- Clear cmd = { 0, };
+ Clear cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLbitfield>(11));
- EXPECT_EQ(Clear::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Clear::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLbitfield>(11), cmd.mask);
}
TEST(GLES2FormatTest, ClearColor) {
- ClearColor cmd = { 0, };
+ ClearColor cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
static_cast<GLclampf>(12),
static_cast<GLclampf>(13),
static_cast<GLclampf>(14));
- EXPECT_EQ(ClearColor::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ClearColor::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
@@ -251,35 +306,44 @@ TEST(GLES2FormatTest, ClearColor) {
}
TEST(GLES2FormatTest, ClearDepthf) {
- ClearDepthf cmd = { 0, };
+ ClearDepthf cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11));
- EXPECT_EQ(ClearDepthf::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ClearDepthf::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLclampf>(11), cmd.depth);
}
TEST(GLES2FormatTest, ClearStencil) {
- ClearStencil cmd = { 0, };
+ ClearStencil cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11));
- EXPECT_EQ(ClearStencil::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ClearStencil::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.s);
}
TEST(GLES2FormatTest, ColorMask) {
- ColorMask cmd = { 0, };
+ ColorMask cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLboolean>(11),
static_cast<GLboolean>(12),
static_cast<GLboolean>(13),
static_cast<GLboolean>(14));
- EXPECT_EQ(ColorMask::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ColorMask::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLboolean>(11), cmd.red);
EXPECT_EQ(static_cast<GLboolean>(12), cmd.green);
EXPECT_EQ(static_cast<GLboolean>(13), cmd.blue);
@@ -287,17 +351,20 @@ TEST(GLES2FormatTest, ColorMask) {
}
TEST(GLES2FormatTest, CompileShader) {
- CompileShader cmd = { 0, };
+ CompileShader cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(CompileShader::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CompileShader::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
}
TEST(GLES2FormatTest, CompressedTexImage2D) {
- CompressedTexImage2D cmd = { 0, };
+ CompressedTexImage2D cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -309,8 +376,11 @@ TEST(GLES2FormatTest, CompressedTexImage2D) {
static_cast<GLsizei>(17),
static_cast<uint32>(18),
static_cast<uint32>(19));
- EXPECT_EQ(CompressedTexImage2D::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CompressedTexImage2D::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLint>(12), cmd.level);
EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
@@ -324,7 +394,7 @@ TEST(GLES2FormatTest, CompressedTexImage2D) {
// TODO(gman): Implement test for CompressedTexImage2DImmediate
TEST(GLES2FormatTest, CompressedTexSubImage2D) {
- CompressedTexSubImage2D cmd = { 0, };
+ CompressedTexSubImage2D cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -337,8 +407,11 @@ TEST(GLES2FormatTest, CompressedTexSubImage2D) {
static_cast<GLsizei>(18),
static_cast<uint32>(19),
static_cast<uint32>(20));
- EXPECT_EQ(CompressedTexSubImage2D::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CompressedTexSubImage2D::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLint>(12), cmd.level);
EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
@@ -353,7 +426,7 @@ TEST(GLES2FormatTest, CompressedTexSubImage2D) {
// TODO(gman): Implement test for CompressedTexSubImage2DImmediate
TEST(GLES2FormatTest, CopyTexImage2D) {
- CopyTexImage2D cmd = { 0, };
+ CopyTexImage2D cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -364,8 +437,11 @@ TEST(GLES2FormatTest, CopyTexImage2D) {
static_cast<GLsizei>(16),
static_cast<GLsizei>(17),
static_cast<GLint>(18));
- EXPECT_EQ(CopyTexImage2D::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CopyTexImage2D::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLint>(12), cmd.level);
EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
@@ -377,7 +453,7 @@ TEST(GLES2FormatTest, CopyTexImage2D) {
}
TEST(GLES2FormatTest, CopyTexSubImage2D) {
- CopyTexSubImage2D cmd = { 0, };
+ CopyTexSubImage2D cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -388,8 +464,11 @@ TEST(GLES2FormatTest, CopyTexSubImage2D) {
static_cast<GLint>(16),
static_cast<GLsizei>(17),
static_cast<GLsizei>(18));
- EXPECT_EQ(CopyTexSubImage2D::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CopyTexSubImage2D::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLint>(12), cmd.level);
EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
@@ -401,46 +480,58 @@ TEST(GLES2FormatTest, CopyTexSubImage2D) {
}
TEST(GLES2FormatTest, CreateProgram) {
- CreateProgram cmd = { 0, };
+ CreateProgram cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<uint32>(11));
- EXPECT_EQ(CreateProgram::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CreateProgram::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<uint32>(11), cmd.client_id);
}
TEST(GLES2FormatTest, CreateShader) {
- CreateShader cmd = { 0, };
+ CreateShader cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<uint32>(12));
- EXPECT_EQ(CreateShader::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CreateShader::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.type);
EXPECT_EQ(static_cast<uint32>(12), cmd.client_id);
}
TEST(GLES2FormatTest, CullFace) {
- CullFace cmd = { 0, };
+ CullFace cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(CullFace::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(CullFace::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
}
TEST(GLES2FormatTest, DeleteBuffers) {
- DeleteBuffers cmd = { 0, };
+ DeleteBuffers cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(DeleteBuffers::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DeleteBuffers::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
@@ -455,23 +546,30 @@ TEST(GLES2FormatTest, DeleteBuffersImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(DeleteBuffersImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(DeleteBuffersImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, DeleteFramebuffers) {
- DeleteFramebuffers cmd = { 0, };
+ DeleteFramebuffers cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(DeleteFramebuffers::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DeleteFramebuffers::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
@@ -486,33 +584,43 @@ TEST(GLES2FormatTest, DeleteFramebuffersImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(DeleteFramebuffersImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(DeleteFramebuffersImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, DeleteProgram) {
- DeleteProgram cmd = { 0, };
+ DeleteProgram cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(DeleteProgram::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DeleteProgram::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
}
TEST(GLES2FormatTest, DeleteRenderbuffers) {
- DeleteRenderbuffers cmd = { 0, };
+ DeleteRenderbuffers cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(DeleteRenderbuffers::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DeleteRenderbuffers::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
@@ -527,33 +635,43 @@ TEST(GLES2FormatTest, DeleteRenderbuffersImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(DeleteRenderbuffersImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(DeleteRenderbuffersImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, DeleteShader) {
- DeleteShader cmd = { 0, };
+ DeleteShader cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(DeleteShader::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DeleteShader::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
}
TEST(GLES2FormatTest, DeleteTextures) {
- DeleteTextures cmd = { 0, };
+ DeleteTextures cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(DeleteTextures::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DeleteTextures::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
@@ -568,102 +686,130 @@ TEST(GLES2FormatTest, DeleteTexturesImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(DeleteTexturesImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(DeleteTexturesImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, DepthFunc) {
- DepthFunc cmd = { 0, };
+ DepthFunc cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(DepthFunc::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DepthFunc::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
}
TEST(GLES2FormatTest, DepthMask) {
- DepthMask cmd = { 0, };
+ DepthMask cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLboolean>(11));
- EXPECT_EQ(DepthMask::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DepthMask::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLboolean>(11), cmd.flag);
}
TEST(GLES2FormatTest, DepthRangef) {
- DepthRangef cmd = { 0, };
+ DepthRangef cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
static_cast<GLclampf>(12));
- EXPECT_EQ(DepthRangef::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DepthRangef::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLclampf>(11), cmd.zNear);
EXPECT_EQ(static_cast<GLclampf>(12), cmd.zFar);
}
TEST(GLES2FormatTest, DetachShader) {
- DetachShader cmd = { 0, };
+ DetachShader cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLuint>(12));
- EXPECT_EQ(DetachShader::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DetachShader::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
}
TEST(GLES2FormatTest, Disable) {
- Disable cmd = { 0, };
+ Disable cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(Disable::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Disable::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
}
TEST(GLES2FormatTest, DisableVertexAttribArray) {
- DisableVertexAttribArray cmd = { 0, };
+ DisableVertexAttribArray cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(DisableVertexAttribArray::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DisableVertexAttribArray::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
}
TEST(GLES2FormatTest, DrawArrays) {
- DrawArrays cmd = { 0, };
+ DrawArrays cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLint>(12),
static_cast<GLsizei>(13));
- EXPECT_EQ(DrawArrays::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DrawArrays::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
EXPECT_EQ(static_cast<GLint>(12), cmd.first);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
}
TEST(GLES2FormatTest, DrawElements) {
- DrawElements cmd = { 0, };
+ DrawElements cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLsizei>(12),
static_cast<GLenum>(13),
static_cast<GLuint>(14));
- EXPECT_EQ(DrawElements::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(DrawElements::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
@@ -671,51 +817,66 @@ TEST(GLES2FormatTest, DrawElements) {
}
TEST(GLES2FormatTest, Enable) {
- Enable cmd = { 0, };
+ Enable cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(Enable::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Enable::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
}
TEST(GLES2FormatTest, EnableVertexAttribArray) {
- EnableVertexAttribArray cmd = { 0, };
+ EnableVertexAttribArray cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(EnableVertexAttribArray::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(EnableVertexAttribArray::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
}
TEST(GLES2FormatTest, Finish) {
- Finish cmd = { 0, };
+ Finish cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd);
- EXPECT_EQ(Finish::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Finish::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
}
TEST(GLES2FormatTest, Flush) {
- Flush cmd = { 0, };
+ Flush cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd);
- EXPECT_EQ(Flush::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Flush::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
}
TEST(GLES2FormatTest, FramebufferRenderbuffer) {
- FramebufferRenderbuffer cmd = { 0, };
+ FramebufferRenderbuffer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLenum>(13),
static_cast<GLuint>(14));
- EXPECT_EQ(FramebufferRenderbuffer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(FramebufferRenderbuffer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
EXPECT_EQ(static_cast<GLenum>(13), cmd.renderbuffertarget);
@@ -723,7 +884,7 @@ TEST(GLES2FormatTest, FramebufferRenderbuffer) {
}
TEST(GLES2FormatTest, FramebufferTexture2D) {
- FramebufferTexture2D cmd = { 0, };
+ FramebufferTexture2D cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -731,8 +892,11 @@ TEST(GLES2FormatTest, FramebufferTexture2D) {
static_cast<GLenum>(13),
static_cast<GLuint>(14),
static_cast<GLint>(15));
- EXPECT_EQ(FramebufferTexture2D::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(FramebufferTexture2D::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
@@ -741,24 +905,30 @@ TEST(GLES2FormatTest, FramebufferTexture2D) {
}
TEST(GLES2FormatTest, FrontFace) {
- FrontFace cmd = { 0, };
+ FrontFace cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(FrontFace::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(FrontFace::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
}
TEST(GLES2FormatTest, GenBuffers) {
- GenBuffers cmd = { 0, };
+ GenBuffers cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(GenBuffers::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GenBuffers::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
@@ -773,33 +943,43 @@ TEST(GLES2FormatTest, GenBuffersImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(GenBuffersImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(GenBuffersImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, GenerateMipmap) {
- GenerateMipmap cmd = { 0, };
+ GenerateMipmap cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(GenerateMipmap::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GenerateMipmap::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
}
TEST(GLES2FormatTest, GenFramebuffers) {
- GenFramebuffers cmd = { 0, };
+ GenFramebuffers cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(GenFramebuffers::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GenFramebuffers::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
@@ -814,23 +994,30 @@ TEST(GLES2FormatTest, GenFramebuffersImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(GenFramebuffersImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(GenFramebuffersImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, GenRenderbuffers) {
- GenRenderbuffers cmd = { 0, };
+ GenRenderbuffers cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(GenRenderbuffers::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GenRenderbuffers::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
@@ -845,23 +1032,30 @@ TEST(GLES2FormatTest, GenRenderbuffersImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(GenRenderbuffersImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(GenRenderbuffersImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, GenTextures) {
- GenTextures cmd = { 0, };
+ GenTextures cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(GenTextures::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GenTextures::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
@@ -876,16 +1070,20 @@ TEST(GLES2FormatTest, GenTexturesImmediate) {
&cmd,
static_cast<GLsizei>(11),
ids);
- EXPECT_EQ(GenTexturesImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(GenTexturesImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(cmd.n * 4),
- cmd.header.size * 4); // NOLINT
+ RoundSizeToMultipleOfEntries(cmd.n * 4u),
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(cmd.n * 4u));
EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
// TODO(gman): Check that ids were inserted;
}
TEST(GLES2FormatTest, GetActiveAttrib) {
- GetActiveAttrib cmd = { 0, };
+ GetActiveAttrib cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -899,8 +1097,11 @@ TEST(GLES2FormatTest, GetActiveAttrib) {
static_cast<uint32>(19),
static_cast<uint32>(20),
static_cast<uint32>(21));
- EXPECT_EQ(GetActiveAttrib::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetActiveAttrib::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.bufsize);
@@ -915,7 +1116,7 @@ TEST(GLES2FormatTest, GetActiveAttrib) {
}
TEST(GLES2FormatTest, GetActiveUniform) {
- GetActiveUniform cmd = { 0, };
+ GetActiveUniform cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -929,8 +1130,11 @@ TEST(GLES2FormatTest, GetActiveUniform) {
static_cast<uint32>(19),
static_cast<uint32>(20),
static_cast<uint32>(21));
- EXPECT_EQ(GetActiveUniform::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetActiveUniform::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.bufsize);
@@ -945,7 +1149,7 @@ TEST(GLES2FormatTest, GetActiveUniform) {
}
TEST(GLES2FormatTest, GetAttachedShaders) {
- GetAttachedShaders cmd = { 0, };
+ GetAttachedShaders cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -954,8 +1158,11 @@ TEST(GLES2FormatTest, GetAttachedShaders) {
static_cast<uint32>(14),
static_cast<uint32>(15),
static_cast<uint32>(16));
- EXPECT_EQ(GetAttachedShaders::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetAttachedShaders::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.maxcount);
EXPECT_EQ(static_cast<uint32>(13), cmd.count_shm_id);
@@ -967,29 +1174,35 @@ TEST(GLES2FormatTest, GetAttachedShaders) {
// TODO(gman): Write test for GetAttribLocation
// TODO(gman): Write test for GetAttribLocationImmediate
TEST(GLES2FormatTest, GetBooleanv) {
- GetBooleanv cmd = { 0, };
+ GetBooleanv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(GetBooleanv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetBooleanv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
}
TEST(GLES2FormatTest, GetBufferParameteriv) {
- GetBufferParameteriv cmd = { 0, };
+ GetBufferParameteriv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetBufferParameteriv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetBufferParameteriv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -997,33 +1210,39 @@ TEST(GLES2FormatTest, GetBufferParameteriv) {
}
TEST(GLES2FormatTest, GetError) {
- GetError cmd = { 0, };
+ GetError cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<uint32>(11),
static_cast<uint32>(12));
- EXPECT_EQ(GetError::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetError::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<uint32>(11), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, GetFloatv) {
- GetFloatv cmd = { 0, };
+ GetFloatv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(GetFloatv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetFloatv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
}
TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
- GetFramebufferAttachmentParameteriv cmd = { 0, };
+ GetFramebufferAttachmentParameteriv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1031,8 +1250,11 @@ TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
static_cast<GLenum>(13),
static_cast<uint32>(14),
static_cast<uint32>(15));
- EXPECT_EQ(GetFramebufferAttachmentParameteriv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetFramebufferAttachmentParameteriv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
EXPECT_EQ(static_cast<GLenum>(13), cmd.pname);
@@ -1041,29 +1263,35 @@ TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
}
TEST(GLES2FormatTest, GetIntegerv) {
- GetIntegerv cmd = { 0, };
+ GetIntegerv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(GetIntegerv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetIntegerv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
}
TEST(GLES2FormatTest, GetProgramiv) {
- GetProgramiv cmd = { 0, };
+ GetProgramiv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetProgramiv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetProgramiv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1071,7 +1299,7 @@ TEST(GLES2FormatTest, GetProgramiv) {
}
TEST(GLES2FormatTest, GetProgramInfoLog) {
- GetProgramInfoLog cmd = { 0, };
+ GetProgramInfoLog cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1080,8 +1308,11 @@ TEST(GLES2FormatTest, GetProgramInfoLog) {
static_cast<uint32>(14),
static_cast<uint32>(15),
static_cast<uint32>(16));
- EXPECT_EQ(GetProgramInfoLog::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetProgramInfoLog::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.bufsize);
EXPECT_EQ(static_cast<uint32>(13), cmd.length_shm_id);
@@ -1091,15 +1322,18 @@ TEST(GLES2FormatTest, GetProgramInfoLog) {
}
TEST(GLES2FormatTest, GetRenderbufferParameteriv) {
- GetRenderbufferParameteriv cmd = { 0, };
+ GetRenderbufferParameteriv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetRenderbufferParameteriv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetRenderbufferParameteriv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1107,15 +1341,18 @@ TEST(GLES2FormatTest, GetRenderbufferParameteriv) {
}
TEST(GLES2FormatTest, GetShaderiv) {
- GetShaderiv cmd = { 0, };
+ GetShaderiv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetShaderiv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetShaderiv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1123,7 +1360,7 @@ TEST(GLES2FormatTest, GetShaderiv) {
}
TEST(GLES2FormatTest, GetShaderInfoLog) {
- GetShaderInfoLog cmd = { 0, };
+ GetShaderInfoLog cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1132,8 +1369,11 @@ TEST(GLES2FormatTest, GetShaderInfoLog) {
static_cast<uint32>(14),
static_cast<uint32>(15),
static_cast<uint32>(16));
- EXPECT_EQ(GetShaderInfoLog::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetShaderInfoLog::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.bufsize);
EXPECT_EQ(static_cast<uint32>(13), cmd.length_shm_id);
@@ -1143,7 +1383,7 @@ TEST(GLES2FormatTest, GetShaderInfoLog) {
}
TEST(GLES2FormatTest, GetShaderPrecisionFormat) {
- GetShaderPrecisionFormat cmd = { 0, };
+ GetShaderPrecisionFormat cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1152,8 +1392,11 @@ TEST(GLES2FormatTest, GetShaderPrecisionFormat) {
static_cast<uint32>(14),
static_cast<uint32>(15),
static_cast<uint32>(16));
- EXPECT_EQ(GetShaderPrecisionFormat::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetShaderPrecisionFormat::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.shadertype);
EXPECT_EQ(static_cast<GLenum>(12), cmd.precisiontype);
EXPECT_EQ(static_cast<uint32>(13), cmd.range_shm_id);
@@ -1163,7 +1406,7 @@ TEST(GLES2FormatTest, GetShaderPrecisionFormat) {
}
TEST(GLES2FormatTest, GetShaderSource) {
- GetShaderSource cmd = { 0, };
+ GetShaderSource cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1172,8 +1415,11 @@ TEST(GLES2FormatTest, GetShaderSource) {
static_cast<uint32>(14),
static_cast<uint32>(15),
static_cast<uint32>(16));
- EXPECT_EQ(GetShaderSource::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetShaderSource::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.bufsize);
EXPECT_EQ(static_cast<uint32>(13), cmd.length_shm_id);
@@ -1183,25 +1429,31 @@ TEST(GLES2FormatTest, GetShaderSource) {
}
TEST(GLES2FormatTest, GetString) {
- GetString cmd = { 0, };
+ GetString cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
- EXPECT_EQ(GetString::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetString::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.name);
}
TEST(GLES2FormatTest, GetTexParameterfv) {
- GetTexParameterfv cmd = { 0, };
+ GetTexParameterfv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetTexParameterfv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetTexParameterfv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1209,15 +1461,18 @@ TEST(GLES2FormatTest, GetTexParameterfv) {
}
TEST(GLES2FormatTest, GetTexParameteriv) {
- GetTexParameteriv cmd = { 0, };
+ GetTexParameteriv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetTexParameteriv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetTexParameteriv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1225,15 +1480,18 @@ TEST(GLES2FormatTest, GetTexParameteriv) {
}
TEST(GLES2FormatTest, GetUniformfv) {
- GetUniformfv cmd = { 0, };
+ GetUniformfv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLint>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetUniformfv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetUniformfv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLint>(12), cmd.location);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1241,15 +1499,18 @@ TEST(GLES2FormatTest, GetUniformfv) {
}
TEST(GLES2FormatTest, GetUniformiv) {
- GetUniformiv cmd = { 0, };
+ GetUniformiv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLint>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetUniformiv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetUniformiv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<GLint>(12), cmd.location);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1259,15 +1520,18 @@ TEST(GLES2FormatTest, GetUniformiv) {
// TODO(gman): Write test for GetUniformLocation
// TODO(gman): Write test for GetUniformLocationImmediate
TEST(GLES2FormatTest, GetVertexAttribfv) {
- GetVertexAttribfv cmd = { 0, };
+ GetVertexAttribfv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetVertexAttribfv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetVertexAttribfv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1275,15 +1539,18 @@ TEST(GLES2FormatTest, GetVertexAttribfv) {
}
TEST(GLES2FormatTest, GetVertexAttribiv) {
- GetVertexAttribiv cmd = { 0, };
+ GetVertexAttribiv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetVertexAttribiv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetVertexAttribiv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1291,15 +1558,18 @@ TEST(GLES2FormatTest, GetVertexAttribiv) {
}
TEST(GLES2FormatTest, GetVertexAttribPointerv) {
- GetVertexAttribPointerv cmd = { 0, };
+ GetVertexAttribPointerv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(GetVertexAttribPointerv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(GetVertexAttribPointerv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.pointer_shm_id);
@@ -1307,161 +1577,197 @@ TEST(GLES2FormatTest, GetVertexAttribPointerv) {
}
TEST(GLES2FormatTest, Hint) {
- Hint cmd = { 0, };
+ Hint cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12));
- EXPECT_EQ(Hint::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Hint::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.mode);
}
TEST(GLES2FormatTest, IsBuffer) {
- IsBuffer cmd = { 0, };
+ IsBuffer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(IsBuffer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(IsBuffer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, IsEnabled) {
- IsEnabled cmd = { 0, };
+ IsEnabled cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(IsEnabled::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(IsEnabled::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, IsFramebuffer) {
- IsFramebuffer cmd = { 0, };
+ IsFramebuffer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(IsFramebuffer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(IsFramebuffer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.framebuffer);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, IsProgram) {
- IsProgram cmd = { 0, };
+ IsProgram cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(IsProgram::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(IsProgram::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, IsRenderbuffer) {
- IsRenderbuffer cmd = { 0, };
+ IsRenderbuffer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(IsRenderbuffer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(IsRenderbuffer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.renderbuffer);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, IsShader) {
- IsShader cmd = { 0, };
+ IsShader cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(IsShader::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(IsShader::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, IsTexture) {
- IsTexture cmd = { 0, };
+ IsTexture cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(IsTexture::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(IsTexture::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
}
TEST(GLES2FormatTest, LineWidth) {
- LineWidth cmd = { 0, };
+ LineWidth cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLfloat>(11));
- EXPECT_EQ(LineWidth::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(LineWidth::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLfloat>(11), cmd.width);
}
TEST(GLES2FormatTest, LinkProgram) {
- LinkProgram cmd = { 0, };
+ LinkProgram cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(LinkProgram::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(LinkProgram::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
}
TEST(GLES2FormatTest, PixelStorei) {
- PixelStorei cmd = { 0, };
+ PixelStorei cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLint>(12));
- EXPECT_EQ(PixelStorei::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(PixelStorei::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
EXPECT_EQ(static_cast<GLint>(12), cmd.param);
}
TEST(GLES2FormatTest, PolygonOffset) {
- PolygonOffset cmd = { 0, };
+ PolygonOffset cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLfloat>(11),
static_cast<GLfloat>(12));
- EXPECT_EQ(PolygonOffset::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(PolygonOffset::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLfloat>(11), cmd.factor);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.units);
}
TEST(GLES2FormatTest, ReadPixels) {
- ReadPixels cmd = { 0, };
+ ReadPixels cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -1472,8 +1778,11 @@ TEST(GLES2FormatTest, ReadPixels) {
static_cast<GLenum>(16),
static_cast<uint32>(17),
static_cast<uint32>(18));
- EXPECT_EQ(ReadPixels::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ReadPixels::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.x);
EXPECT_EQ(static_cast<GLint>(12), cmd.y);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
@@ -1485,15 +1794,18 @@ TEST(GLES2FormatTest, ReadPixels) {
}
TEST(GLES2FormatTest, RenderbufferStorage) {
- RenderbufferStorage cmd = { 0, };
+ RenderbufferStorage cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLsizei>(13),
static_cast<GLsizei>(14));
- EXPECT_EQ(RenderbufferStorage::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(RenderbufferStorage::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.internalformat);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
@@ -1501,27 +1813,33 @@ TEST(GLES2FormatTest, RenderbufferStorage) {
}
TEST(GLES2FormatTest, SampleCoverage) {
- SampleCoverage cmd = { 0, };
+ SampleCoverage cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
static_cast<GLboolean>(12));
- EXPECT_EQ(SampleCoverage::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(SampleCoverage::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLclampf>(11), cmd.value);
EXPECT_EQ(static_cast<GLboolean>(12), cmd.invert);
}
TEST(GLES2FormatTest, Scissor) {
- Scissor cmd = { 0, };
+ Scissor cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLint>(12),
static_cast<GLsizei>(13),
static_cast<GLsizei>(14));
- EXPECT_EQ(Scissor::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Scissor::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.x);
EXPECT_EQ(static_cast<GLint>(12), cmd.y);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
@@ -1529,7 +1847,7 @@ TEST(GLES2FormatTest, Scissor) {
}
TEST(GLES2FormatTest, ShaderSource) {
- ShaderSource cmd = { 0, };
+ ShaderSource cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1537,8 +1855,11 @@ TEST(GLES2FormatTest, ShaderSource) {
static_cast<uint32>(13),
static_cast<uint32>(14),
static_cast<uint32>(15));
- EXPECT_EQ(ShaderSource::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ShaderSource::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id);
@@ -1548,29 +1869,35 @@ TEST(GLES2FormatTest, ShaderSource) {
// TODO(gman): Implement test for ShaderSourceImmediate
TEST(GLES2FormatTest, StencilFunc) {
- StencilFunc cmd = { 0, };
+ StencilFunc cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLint>(12),
static_cast<GLuint>(13));
- EXPECT_EQ(StencilFunc::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(StencilFunc::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
EXPECT_EQ(static_cast<GLint>(12), cmd.ref);
EXPECT_EQ(static_cast<GLuint>(13), cmd.mask);
}
TEST(GLES2FormatTest, StencilFuncSeparate) {
- StencilFuncSeparate cmd = { 0, };
+ StencilFuncSeparate cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLint>(13),
static_cast<GLuint>(14));
- EXPECT_EQ(StencilFuncSeparate::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(StencilFuncSeparate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
EXPECT_EQ(static_cast<GLenum>(12), cmd.func);
EXPECT_EQ(static_cast<GLint>(13), cmd.ref);
@@ -1578,51 +1905,63 @@ TEST(GLES2FormatTest, StencilFuncSeparate) {
}
TEST(GLES2FormatTest, StencilMask) {
- StencilMask cmd = { 0, };
+ StencilMask cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(StencilMask::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(StencilMask::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.mask);
}
TEST(GLES2FormatTest, StencilMaskSeparate) {
- StencilMaskSeparate cmd = { 0, };
+ StencilMaskSeparate cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLuint>(12));
- EXPECT_EQ(StencilMaskSeparate::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(StencilMaskSeparate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
EXPECT_EQ(static_cast<GLuint>(12), cmd.mask);
}
TEST(GLES2FormatTest, StencilOp) {
- StencilOp cmd = { 0, };
+ StencilOp cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLenum>(13));
- EXPECT_EQ(StencilOp::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(StencilOp::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.fail);
EXPECT_EQ(static_cast<GLenum>(12), cmd.zfail);
EXPECT_EQ(static_cast<GLenum>(13), cmd.zpass);
}
TEST(GLES2FormatTest, StencilOpSeparate) {
- StencilOpSeparate cmd = { 0, };
+ StencilOpSeparate cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLenum>(13),
static_cast<GLenum>(14));
- EXPECT_EQ(StencilOpSeparate::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(StencilOpSeparate::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
EXPECT_EQ(static_cast<GLenum>(12), cmd.fail);
EXPECT_EQ(static_cast<GLenum>(13), cmd.zfail);
@@ -1630,7 +1969,7 @@ TEST(GLES2FormatTest, StencilOpSeparate) {
}
TEST(GLES2FormatTest, TexImage2D) {
- TexImage2D cmd = { 0, };
+ TexImage2D cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1643,8 +1982,11 @@ TEST(GLES2FormatTest, TexImage2D) {
static_cast<GLenum>(18),
static_cast<uint32>(19),
static_cast<uint32>(20));
- EXPECT_EQ(TexImage2D::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(TexImage2D::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLint>(12), cmd.level);
EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
@@ -1659,29 +2001,35 @@ TEST(GLES2FormatTest, TexImage2D) {
// TODO(gman): Implement test for TexImage2DImmediate
TEST(GLES2FormatTest, TexParameterf) {
- TexParameterf cmd = { 0, };
+ TexParameterf cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLfloat>(13));
- EXPECT_EQ(TexParameterf::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(TexParameterf::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<GLfloat>(13), cmd.param);
}
TEST(GLES2FormatTest, TexParameterfv) {
- TexParameterfv cmd = { 0, };
+ TexParameterfv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(TexParameterfv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(TexParameterfv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1701,39 +2049,49 @@ TEST(GLES2FormatTest, TexParameterfvImmediate) {
static_cast<GLenum>(11),
static_cast<GLenum>(12),
data);
- EXPECT_EQ(TexParameterfvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(TexParameterfvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, TexParameteri) {
- TexParameteri cmd = { 0, };
+ TexParameteri cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<GLint>(13));
- EXPECT_EQ(TexParameteri::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(TexParameteri::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<GLint>(13), cmd.param);
}
TEST(GLES2FormatTest, TexParameteriv) {
- TexParameteriv cmd = { 0, };
+ TexParameteriv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
static_cast<GLenum>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(TexParameteriv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(TexParameteriv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
@@ -1753,17 +2111,21 @@ TEST(GLES2FormatTest, TexParameterivImmediate) {
static_cast<GLenum>(11),
static_cast<GLenum>(12),
data);
- EXPECT_EQ(TexParameterivImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(TexParameterivImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, TexSubImage2D) {
- TexSubImage2D cmd = { 0, };
+ TexSubImage2D cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1776,8 +2138,11 @@ TEST(GLES2FormatTest, TexSubImage2D) {
static_cast<GLenum>(18),
static_cast<uint32>(19),
static_cast<uint32>(20));
- EXPECT_EQ(TexSubImage2D::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(TexSubImage2D::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
EXPECT_EQ(static_cast<GLint>(12), cmd.level);
EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
@@ -1792,27 +2157,33 @@ TEST(GLES2FormatTest, TexSubImage2D) {
// TODO(gman): Implement test for TexSubImage2DImmediate
TEST(GLES2FormatTest, Uniform1f) {
- Uniform1f cmd = { 0, };
+ Uniform1f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLfloat>(12));
- EXPECT_EQ(Uniform1f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform1f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
}
TEST(GLES2FormatTest, Uniform1fv) {
- Uniform1fv cmd = { 0, };
+ Uniform1fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform1fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform1fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -1833,37 +2204,47 @@ TEST(GLES2FormatTest, Uniform1fvImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform1fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform1fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, Uniform1i) {
- Uniform1i cmd = { 0, };
+ Uniform1i cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLint>(12));
- EXPECT_EQ(Uniform1i::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform1i::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLint>(12), cmd.x);
}
TEST(GLES2FormatTest, Uniform1iv) {
- Uniform1iv cmd = { 0, };
+ Uniform1iv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform1iv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform1iv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -1884,39 +2265,49 @@ TEST(GLES2FormatTest, Uniform1ivImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform1ivImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform1ivImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, Uniform2f) {
- Uniform2f cmd = { 0, };
+ Uniform2f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLfloat>(12),
static_cast<GLfloat>(13));
- EXPECT_EQ(Uniform2f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform2f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
}
TEST(GLES2FormatTest, Uniform2fv) {
- Uniform2fv cmd = { 0, };
+ Uniform2fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform2fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform2fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -1939,39 +2330,49 @@ TEST(GLES2FormatTest, Uniform2fvImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform2fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform2fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, Uniform2i) {
- Uniform2i cmd = { 0, };
+ Uniform2i cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLint>(12),
static_cast<GLint>(13));
- EXPECT_EQ(Uniform2i::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform2i::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLint>(12), cmd.x);
EXPECT_EQ(static_cast<GLint>(13), cmd.y);
}
TEST(GLES2FormatTest, Uniform2iv) {
- Uniform2iv cmd = { 0, };
+ Uniform2iv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform2iv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform2iv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -1994,25 +2395,32 @@ TEST(GLES2FormatTest, Uniform2ivImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform2ivImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform2ivImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, Uniform3f) {
- Uniform3f cmd = { 0, };
+ Uniform3f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLfloat>(12),
static_cast<GLfloat>(13),
static_cast<GLfloat>(14));
- EXPECT_EQ(Uniform3f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform3f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
@@ -2020,15 +2428,18 @@ TEST(GLES2FormatTest, Uniform3f) {
}
TEST(GLES2FormatTest, Uniform3fv) {
- Uniform3fv cmd = { 0, };
+ Uniform3fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform3fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform3fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -2053,25 +2464,32 @@ TEST(GLES2FormatTest, Uniform3fvImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform3fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform3fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, Uniform3i) {
- Uniform3i cmd = { 0, };
+ Uniform3i cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLint>(12),
static_cast<GLint>(13),
static_cast<GLint>(14));
- EXPECT_EQ(Uniform3i::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform3i::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLint>(12), cmd.x);
EXPECT_EQ(static_cast<GLint>(13), cmd.y);
@@ -2079,15 +2497,18 @@ TEST(GLES2FormatTest, Uniform3i) {
}
TEST(GLES2FormatTest, Uniform3iv) {
- Uniform3iv cmd = { 0, };
+ Uniform3iv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform3iv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform3iv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -2112,17 +2533,21 @@ TEST(GLES2FormatTest, Uniform3ivImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform3ivImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform3ivImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, Uniform4f) {
- Uniform4f cmd = { 0, };
+ Uniform4f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2130,8 +2555,11 @@ TEST(GLES2FormatTest, Uniform4f) {
static_cast<GLfloat>(13),
static_cast<GLfloat>(14),
static_cast<GLfloat>(15));
- EXPECT_EQ(Uniform4f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform4f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
@@ -2140,15 +2568,18 @@ TEST(GLES2FormatTest, Uniform4f) {
}
TEST(GLES2FormatTest, Uniform4fv) {
- Uniform4fv cmd = { 0, };
+ Uniform4fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform4fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform4fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -2175,17 +2606,21 @@ TEST(GLES2FormatTest, Uniform4fvImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform4fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform4fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, Uniform4i) {
- Uniform4i cmd = { 0, };
+ Uniform4i cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2193,8 +2628,11 @@ TEST(GLES2FormatTest, Uniform4i) {
static_cast<GLint>(13),
static_cast<GLint>(14),
static_cast<GLint>(15));
- EXPECT_EQ(Uniform4i::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform4i::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLint>(12), cmd.x);
EXPECT_EQ(static_cast<GLint>(13), cmd.y);
@@ -2203,15 +2641,18 @@ TEST(GLES2FormatTest, Uniform4i) {
}
TEST(GLES2FormatTest, Uniform4iv) {
- Uniform4iv cmd = { 0, };
+ Uniform4iv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLsizei>(12),
static_cast<uint32>(13),
static_cast<uint32>(14));
- EXPECT_EQ(Uniform4iv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Uniform4iv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
@@ -2238,17 +2679,21 @@ TEST(GLES2FormatTest, Uniform4ivImmediate) {
static_cast<GLint>(1),
static_cast<GLsizei>(2),
data);
- EXPECT_EQ(Uniform4ivImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(Uniform4ivImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, UniformMatrix2fv) {
- UniformMatrix2fv cmd = { 0, };
+ UniformMatrix2fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2256,8 +2701,11 @@ TEST(GLES2FormatTest, UniformMatrix2fv) {
static_cast<GLboolean>(13),
static_cast<uint32>(14),
static_cast<uint32>(15));
- EXPECT_EQ(UniformMatrix2fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(UniformMatrix2fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
@@ -2286,10 +2734,14 @@ TEST(GLES2FormatTest, UniformMatrix2fvImmediate) {
static_cast<GLsizei>(2),
static_cast<GLboolean>(3),
data);
- EXPECT_EQ(UniformMatrix2fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(UniformMatrix2fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
@@ -2297,7 +2749,7 @@ TEST(GLES2FormatTest, UniformMatrix2fvImmediate) {
}
TEST(GLES2FormatTest, UniformMatrix3fv) {
- UniformMatrix3fv cmd = { 0, };
+ UniformMatrix3fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2305,8 +2757,11 @@ TEST(GLES2FormatTest, UniformMatrix3fv) {
static_cast<GLboolean>(13),
static_cast<uint32>(14),
static_cast<uint32>(15));
- EXPECT_EQ(UniformMatrix3fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(UniformMatrix3fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
@@ -2345,10 +2800,14 @@ TEST(GLES2FormatTest, UniformMatrix3fvImmediate) {
static_cast<GLsizei>(2),
static_cast<GLboolean>(3),
data);
- EXPECT_EQ(UniformMatrix3fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(UniformMatrix3fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
@@ -2356,7 +2815,7 @@ TEST(GLES2FormatTest, UniformMatrix3fvImmediate) {
}
TEST(GLES2FormatTest, UniformMatrix4fv) {
- UniformMatrix4fv cmd = { 0, };
+ UniformMatrix4fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2364,8 +2823,11 @@ TEST(GLES2FormatTest, UniformMatrix4fv) {
static_cast<GLboolean>(13),
static_cast<uint32>(14),
static_cast<uint32>(15));
- EXPECT_EQ(UniformMatrix4fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(UniformMatrix4fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
@@ -2418,10 +2880,14 @@ TEST(GLES2FormatTest, UniformMatrix4fvImmediate) {
static_cast<GLsizei>(2),
static_cast<GLboolean>(3),
data);
- EXPECT_EQ(UniformMatrix4fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(UniformMatrix4fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
@@ -2429,46 +2895,58 @@ TEST(GLES2FormatTest, UniformMatrix4fvImmediate) {
}
TEST(GLES2FormatTest, UseProgram) {
- UseProgram cmd = { 0, };
+ UseProgram cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(UseProgram::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(UseProgram::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
}
TEST(GLES2FormatTest, ValidateProgram) {
- ValidateProgram cmd = { 0, };
+ ValidateProgram cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
- EXPECT_EQ(ValidateProgram::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(ValidateProgram::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
}
TEST(GLES2FormatTest, VertexAttrib1f) {
- VertexAttrib1f cmd = { 0, };
+ VertexAttrib1f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLfloat>(12));
- EXPECT_EQ(VertexAttrib1f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib1f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
}
TEST(GLES2FormatTest, VertexAttrib1fv) {
- VertexAttrib1fv cmd = { 0, };
+ VertexAttrib1fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(VertexAttrib1fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib1fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
@@ -2486,37 +2964,47 @@ TEST(GLES2FormatTest, VertexAttrib1fvImmediate) {
&cmd,
static_cast<GLuint>(11),
data);
- EXPECT_EQ(VertexAttrib1fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib1fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, VertexAttrib2f) {
- VertexAttrib2f cmd = { 0, };
+ VertexAttrib2f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLfloat>(12),
static_cast<GLfloat>(13));
- EXPECT_EQ(VertexAttrib2f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib2f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
}
TEST(GLES2FormatTest, VertexAttrib2fv) {
- VertexAttrib2fv cmd = { 0, };
+ VertexAttrib2fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(VertexAttrib2fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib2fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
@@ -2535,24 +3023,31 @@ TEST(GLES2FormatTest, VertexAttrib2fvImmediate) {
&cmd,
static_cast<GLuint>(11),
data);
- EXPECT_EQ(VertexAttrib2fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib2fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, VertexAttrib3f) {
- VertexAttrib3f cmd = { 0, };
+ VertexAttrib3f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<GLfloat>(12),
static_cast<GLfloat>(13),
static_cast<GLfloat>(14));
- EXPECT_EQ(VertexAttrib3f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib3f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
@@ -2560,14 +3055,17 @@ TEST(GLES2FormatTest, VertexAttrib3f) {
}
TEST(GLES2FormatTest, VertexAttrib3fv) {
- VertexAttrib3fv cmd = { 0, };
+ VertexAttrib3fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(VertexAttrib3fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib3fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
@@ -2587,16 +3085,20 @@ TEST(GLES2FormatTest, VertexAttrib3fvImmediate) {
&cmd,
static_cast<GLuint>(11),
data);
- EXPECT_EQ(VertexAttrib3fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib3fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, VertexAttrib4f) {
- VertexAttrib4f cmd = { 0, };
+ VertexAttrib4f cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -2604,8 +3106,11 @@ TEST(GLES2FormatTest, VertexAttrib4f) {
static_cast<GLfloat>(13),
static_cast<GLfloat>(14),
static_cast<GLfloat>(15));
- EXPECT_EQ(VertexAttrib4f::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib4f::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
@@ -2614,14 +3119,17 @@ TEST(GLES2FormatTest, VertexAttrib4f) {
}
TEST(GLES2FormatTest, VertexAttrib4fv) {
- VertexAttrib4fv cmd = { 0, };
+ VertexAttrib4fv cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
static_cast<uint32>(12),
static_cast<uint32>(13));
- EXPECT_EQ(VertexAttrib4fv::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib4fv::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
@@ -2642,16 +3150,20 @@ TEST(GLES2FormatTest, VertexAttrib4fvImmediate) {
&cmd,
static_cast<GLuint>(11),
data);
- EXPECT_EQ(VertexAttrib4fvImmediate::kCmdId, cmd.header.command);
+ EXPECT_EQ(static_cast<uint32>(VertexAttrib4fvImmediate::kCmdId),
+ cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4); // NOLINT
+ cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
// TODO(gman): Check that data was inserted;
}
TEST(GLES2FormatTest, VertexAttribPointer) {
- VertexAttribPointer cmd = { 0, };
+ VertexAttribPointer cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -2660,8 +3172,11 @@ TEST(GLES2FormatTest, VertexAttribPointer) {
static_cast<GLboolean>(14),
static_cast<GLsizei>(15),
static_cast<GLuint>(16));
- EXPECT_EQ(VertexAttribPointer::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(VertexAttribPointer::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
EXPECT_EQ(static_cast<GLint>(12), cmd.size);
EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
@@ -2671,15 +3186,18 @@ TEST(GLES2FormatTest, VertexAttribPointer) {
}
TEST(GLES2FormatTest, Viewport) {
- Viewport cmd = { 0, };
+ Viewport cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
static_cast<GLint>(12),
static_cast<GLsizei>(13),
static_cast<GLsizei>(14));
- EXPECT_EQ(Viewport::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(Viewport::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.x);
EXPECT_EQ(static_cast<GLint>(12), cmd.y);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
@@ -2687,10 +3205,13 @@ TEST(GLES2FormatTest, Viewport) {
}
TEST(GLES2FormatTest, SwapBuffers) {
- SwapBuffers cmd = { 0, };
+ SwapBuffers cmd = {{0}};
void* next_cmd = cmd.Set(
&cmd);
- EXPECT_EQ(SwapBuffers::kCmdId, cmd.header.command);
- EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT
+ EXPECT_EQ(static_cast<uint32>(SwapBuffers::kCmdId),
+ cmd.header.command);
+ EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); // NOLINT
+ EXPECT_EQ(static_cast<char*>(next_cmd),
+ reinterpret_cast<char*>(&cmd) + sizeof(cmd));
}
« no previous file with comments | « gpu/command_buffer/common/gles2_cmd_format_autogen.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698