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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 7789021: Fix GPU cmd tests so they pass ASAN (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 9 years, 3 months 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_test.cc ('k') | gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h » ('j') | 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 e10a7fed9f8ae53fefc68fa99565162a29c4e135..d546044736bcfe166bb0518504626d7b1880e5c1 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -12,21 +12,21 @@
#ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
#define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
-TEST(GLES2FormatTest, ActiveTexture) {
- ActiveTexture cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ActiveTexture) {
+ ActiveTexture& cmd = *GetBufferAs<ActiveTexture>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(ActiveTexture::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.texture);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, AttachShader) {
- AttachShader cmd = { { 0 } };
+TEST_F(GLES2FormatTest, AttachShader) {
+ AttachShader& cmd = *GetBufferAs<AttachShader>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -34,14 +34,14 @@ TEST(GLES2FormatTest, AttachShader) {
EXPECT_EQ(static_cast<uint32>(AttachShader::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BindAttribLocation) {
- BindAttribLocation cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BindAttribLocation) {
+ BindAttribLocation& cmd = *GetBufferAs<BindAttribLocation>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -52,20 +52,19 @@ TEST(GLES2FormatTest, BindAttribLocation) {
EXPECT_EQ(static_cast<uint32>(BindAttribLocation::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BindAttribLocationImmediate) {
- int8 buf[256] = { 0, };
+TEST_F(GLES2FormatTest, BindAttribLocationImmediate) {
BindAttribLocationImmediate& cmd =
- *static_cast<BindAttribLocationImmediate*>(static_cast<void*>(&buf));
+ *GetBufferAs<BindAttribLocationImmediate>();
static const char* const test_str = "test string";
void* next_cmd = cmd.Set(
&cmd,
@@ -85,10 +84,14 @@ TEST(GLES2FormatTest, BindAttribLocationImmediate) {
EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
EXPECT_EQ(static_cast<uint32>(strlen(test_str)), cmd.data_size);
EXPECT_EQ(0, memcmp(test_str, ImmediateDataAddress(&cmd), strlen(test_str)));
+ CheckBytesWritten(
+ next_cmd,
+ sizeof(cmd) + RoundSizeToMultipleOfEntries(strlen(test_str)),
+ sizeof(cmd) + strlen(test_str));
}
-TEST(GLES2FormatTest, BindAttribLocationBucket) {
- BindAttribLocationBucket cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BindAttribLocationBucket) {
+ BindAttribLocationBucket& cmd = *GetBufferAs<BindAttribLocationBucket>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -97,15 +100,15 @@ TEST(GLES2FormatTest, BindAttribLocationBucket) {
EXPECT_EQ(static_cast<uint32>(BindAttribLocationBucket::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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_bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BindBuffer) {
- BindBuffer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BindBuffer) {
+ BindBuffer& cmd = *GetBufferAs<BindBuffer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -113,14 +116,14 @@ TEST(GLES2FormatTest, BindBuffer) {
EXPECT_EQ(static_cast<uint32>(BindBuffer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BindFramebuffer) {
- BindFramebuffer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BindFramebuffer) {
+ BindFramebuffer& cmd = *GetBufferAs<BindFramebuffer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -128,14 +131,14 @@ TEST(GLES2FormatTest, BindFramebuffer) {
EXPECT_EQ(static_cast<uint32>(BindFramebuffer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BindRenderbuffer) {
- BindRenderbuffer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BindRenderbuffer) {
+ BindRenderbuffer& cmd = *GetBufferAs<BindRenderbuffer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -143,14 +146,14 @@ TEST(GLES2FormatTest, BindRenderbuffer) {
EXPECT_EQ(static_cast<uint32>(BindRenderbuffer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BindTexture) {
- BindTexture cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BindTexture) {
+ BindTexture& cmd = *GetBufferAs<BindTexture>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -158,14 +161,14 @@ TEST(GLES2FormatTest, BindTexture) {
EXPECT_EQ(static_cast<uint32>(BindTexture::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BlendColor) {
- BlendColor cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BlendColor) {
+ BlendColor& cmd = *GetBufferAs<BlendColor>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
@@ -175,29 +178,29 @@ TEST(GLES2FormatTest, BlendColor) {
EXPECT_EQ(static_cast<uint32>(BlendColor::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BlendEquation) {
- BlendEquation cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BlendEquation) {
+ BlendEquation& cmd = *GetBufferAs<BlendEquation>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(BlendEquation::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BlendEquationSeparate) {
- BlendEquationSeparate cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BlendEquationSeparate) {
+ BlendEquationSeparate& cmd = *GetBufferAs<BlendEquationSeparate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -205,14 +208,14 @@ TEST(GLES2FormatTest, BlendEquationSeparate) {
EXPECT_EQ(static_cast<uint32>(BlendEquationSeparate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BlendFunc) {
- BlendFunc cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BlendFunc) {
+ BlendFunc& cmd = *GetBufferAs<BlendFunc>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -220,14 +223,14 @@ TEST(GLES2FormatTest, BlendFunc) {
EXPECT_EQ(static_cast<uint32>(BlendFunc::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BlendFuncSeparate) {
- BlendFuncSeparate cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BlendFuncSeparate) {
+ BlendFuncSeparate& cmd = *GetBufferAs<BlendFuncSeparate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -237,16 +240,16 @@ TEST(GLES2FormatTest, BlendFuncSeparate) {
EXPECT_EQ(static_cast<uint32>(BlendFuncSeparate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLenum>(14), cmd.dstAlpha);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BufferData) {
- BufferData cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BufferData) {
+ BufferData& cmd = *GetBufferAs<BufferData>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -257,18 +260,18 @@ TEST(GLES2FormatTest, BufferData) {
EXPECT_EQ(static_cast<uint32>(BufferData::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_offset);
EXPECT_EQ(static_cast<GLenum>(15), cmd.usage);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Implement test for BufferDataImmediate
-TEST(GLES2FormatTest, BufferSubData) {
- BufferSubData cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BufferSubData) {
+ BufferSubData& cmd = *GetBufferAs<BufferSubData>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -279,18 +282,18 @@ TEST(GLES2FormatTest, BufferSubData) {
EXPECT_EQ(static_cast<uint32>(BufferSubData::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.data_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Implement test for BufferSubDataImmediate
-TEST(GLES2FormatTest, CheckFramebufferStatus) {
- CheckFramebufferStatus cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CheckFramebufferStatus) {
+ CheckFramebufferStatus& cmd = *GetBufferAs<CheckFramebufferStatus>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -299,28 +302,28 @@ TEST(GLES2FormatTest, CheckFramebufferStatus) {
EXPECT_EQ(static_cast<uint32>(CheckFramebufferStatus::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Clear) {
- Clear cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Clear) {
+ Clear& cmd = *GetBufferAs<Clear>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLbitfield>(11));
EXPECT_EQ(static_cast<uint32>(Clear::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLbitfield>(11), cmd.mask);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ClearColor) {
- ClearColor cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ClearColor) {
+ ClearColor& cmd = *GetBufferAs<ClearColor>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
@@ -330,42 +333,42 @@ TEST(GLES2FormatTest, ClearColor) {
EXPECT_EQ(static_cast<uint32>(ClearColor::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ClearDepthf) {
- ClearDepthf cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ClearDepthf) {
+ ClearDepthf& cmd = *GetBufferAs<ClearDepthf>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11));
EXPECT_EQ(static_cast<uint32>(ClearDepthf::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLclampf>(11), cmd.depth);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ClearStencil) {
- ClearStencil cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ClearStencil) {
+ ClearStencil& cmd = *GetBufferAs<ClearStencil>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11));
EXPECT_EQ(static_cast<uint32>(ClearStencil::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.s);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ColorMask) {
- ColorMask cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ColorMask) {
+ ColorMask& cmd = *GetBufferAs<ColorMask>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLboolean>(11),
@@ -375,29 +378,29 @@ TEST(GLES2FormatTest, ColorMask) {
EXPECT_EQ(static_cast<uint32>(ColorMask::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLboolean>(14), cmd.alpha);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CompileShader) {
- CompileShader cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CompileShader) {
+ CompileShader& cmd = *GetBufferAs<CompileShader>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(CompileShader::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CompressedTexImage2D) {
- CompressedTexImage2D cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CompressedTexImage2D) {
+ CompressedTexImage2D& cmd = *GetBufferAs<CompressedTexImage2D>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -412,8 +415,6 @@ TEST(GLES2FormatTest, CompressedTexImage2D) {
EXPECT_EQ(static_cast<uint32>(CompressedTexImage2D::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -423,11 +424,13 @@ TEST(GLES2FormatTest, CompressedTexImage2D) {
EXPECT_EQ(static_cast<GLsizei>(17), cmd.imageSize);
EXPECT_EQ(static_cast<uint32>(18), cmd.data_shm_id);
EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Implement test for CompressedTexImage2DImmediate
-TEST(GLES2FormatTest, CompressedTexImage2DBucket) {
- CompressedTexImage2DBucket cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CompressedTexImage2DBucket) {
+ CompressedTexImage2DBucket& cmd = *GetBufferAs<CompressedTexImage2DBucket>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -440,8 +443,6 @@ TEST(GLES2FormatTest, CompressedTexImage2DBucket) {
EXPECT_EQ(static_cast<uint32>(CompressedTexImage2DBucket::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -449,10 +450,12 @@ TEST(GLES2FormatTest, CompressedTexImage2DBucket) {
EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
EXPECT_EQ(static_cast<GLint>(16), cmd.border);
EXPECT_EQ(static_cast<GLuint>(17), cmd.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CompressedTexSubImage2D) {
- CompressedTexSubImage2D cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CompressedTexSubImage2D) {
+ CompressedTexSubImage2D& cmd = *GetBufferAs<CompressedTexSubImage2D>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -468,8 +471,6 @@ TEST(GLES2FormatTest, CompressedTexSubImage2D) {
EXPECT_EQ(static_cast<uint32>(CompressedTexSubImage2D::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -480,11 +481,14 @@ TEST(GLES2FormatTest, CompressedTexSubImage2D) {
EXPECT_EQ(static_cast<GLsizei>(18), cmd.imageSize);
EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Implement test for CompressedTexSubImage2DImmediate
-TEST(GLES2FormatTest, CompressedTexSubImage2DBucket) {
- CompressedTexSubImage2DBucket cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CompressedTexSubImage2DBucket) {
+ CompressedTexSubImage2DBucket& cmd =
+ *GetBufferAs<CompressedTexSubImage2DBucket>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -498,8 +502,6 @@ TEST(GLES2FormatTest, CompressedTexSubImage2DBucket) {
EXPECT_EQ(static_cast<uint32>(CompressedTexSubImage2DBucket::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -508,10 +510,12 @@ TEST(GLES2FormatTest, CompressedTexSubImage2DBucket) {
EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
EXPECT_EQ(static_cast<GLuint>(18), cmd.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CopyTexImage2D) {
- CopyTexImage2D cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CopyTexImage2D) {
+ CopyTexImage2D& cmd = *GetBufferAs<CopyTexImage2D>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -525,8 +529,6 @@ TEST(GLES2FormatTest, CopyTexImage2D) {
EXPECT_EQ(static_cast<uint32>(CopyTexImage2D::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -535,10 +537,12 @@ TEST(GLES2FormatTest, CopyTexImage2D) {
EXPECT_EQ(static_cast<GLsizei>(16), cmd.width);
EXPECT_EQ(static_cast<GLsizei>(17), cmd.height);
EXPECT_EQ(static_cast<GLint>(18), cmd.border);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CopyTexSubImage2D) {
- CopyTexSubImage2D cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CopyTexSubImage2D) {
+ CopyTexSubImage2D& cmd = *GetBufferAs<CopyTexSubImage2D>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -552,8 +556,6 @@ TEST(GLES2FormatTest, CopyTexSubImage2D) {
EXPECT_EQ(static_cast<uint32>(CopyTexSubImage2D::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -562,23 +564,25 @@ TEST(GLES2FormatTest, CopyTexSubImage2D) {
EXPECT_EQ(static_cast<GLint>(16), cmd.y);
EXPECT_EQ(static_cast<GLsizei>(17), cmd.width);
EXPECT_EQ(static_cast<GLsizei>(18), cmd.height);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CreateProgram) {
- CreateProgram cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CreateProgram) {
+ CreateProgram& cmd = *GetBufferAs<CreateProgram>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<uint32>(11));
EXPECT_EQ(static_cast<uint32>(CreateProgram::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<uint32>(11), cmd.client_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CreateShader) {
- CreateShader cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CreateShader) {
+ CreateShader& cmd = *GetBufferAs<CreateShader>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -586,27 +590,27 @@ TEST(GLES2FormatTest, CreateShader) {
EXPECT_EQ(static_cast<uint32>(CreateShader::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, CullFace) {
- CullFace cmd = { { 0 } };
+TEST_F(GLES2FormatTest, CullFace) {
+ CullFace& cmd = *GetBufferAs<CullFace>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(CullFace::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteBuffers) {
- DeleteBuffers cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DeleteBuffers) {
+ DeleteBuffers& cmd = *GetBufferAs<DeleteBuffers>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -615,36 +619,32 @@ TEST(GLES2FormatTest, DeleteBuffers) {
EXPECT_EQ(static_cast<uint32>(DeleteBuffers::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteBuffersImmediate) {
+TEST_F(GLES2FormatTest, DeleteBuffersImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
- DeleteBuffersImmediate& cmd =
- *static_cast<DeleteBuffersImmediate*>(static_cast<void*>(&buf));
+ DeleteBuffersImmediate& cmd = *GetBufferAs<DeleteBuffersImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(DeleteBuffersImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, DeleteFramebuffers) {
- DeleteFramebuffers cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DeleteFramebuffers) {
+ DeleteFramebuffers& cmd = *GetBufferAs<DeleteFramebuffers>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -653,49 +653,46 @@ TEST(GLES2FormatTest, DeleteFramebuffers) {
EXPECT_EQ(static_cast<uint32>(DeleteFramebuffers::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteFramebuffersImmediate) {
+TEST_F(GLES2FormatTest, DeleteFramebuffersImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
DeleteFramebuffersImmediate& cmd =
- *static_cast<DeleteFramebuffersImmediate*>(static_cast<void*>(&buf));
+ *GetBufferAs<DeleteFramebuffersImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(DeleteFramebuffersImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, DeleteProgram) {
- DeleteProgram cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DeleteProgram) {
+ DeleteProgram& cmd = *GetBufferAs<DeleteProgram>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(DeleteProgram::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteRenderbuffers) {
- DeleteRenderbuffers cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DeleteRenderbuffers) {
+ DeleteRenderbuffers& cmd = *GetBufferAs<DeleteRenderbuffers>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -704,49 +701,46 @@ TEST(GLES2FormatTest, DeleteRenderbuffers) {
EXPECT_EQ(static_cast<uint32>(DeleteRenderbuffers::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteRenderbuffersImmediate) {
+TEST_F(GLES2FormatTest, DeleteRenderbuffersImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
DeleteRenderbuffersImmediate& cmd =
- *static_cast<DeleteRenderbuffersImmediate*>(static_cast<void*>(&buf));
+ *GetBufferAs<DeleteRenderbuffersImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(DeleteRenderbuffersImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, DeleteShader) {
- DeleteShader cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DeleteShader) {
+ DeleteShader& cmd = *GetBufferAs<DeleteShader>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(DeleteShader::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteTextures) {
- DeleteTextures cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DeleteTextures) {
+ DeleteTextures& cmd = *GetBufferAs<DeleteTextures>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -755,62 +749,58 @@ TEST(GLES2FormatTest, DeleteTextures) {
EXPECT_EQ(static_cast<uint32>(DeleteTextures::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteTexturesImmediate) {
+TEST_F(GLES2FormatTest, DeleteTexturesImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
- DeleteTexturesImmediate& cmd =
- *static_cast<DeleteTexturesImmediate*>(static_cast<void*>(&buf));
+ DeleteTexturesImmediate& cmd = *GetBufferAs<DeleteTexturesImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(DeleteTexturesImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, DepthFunc) {
- DepthFunc cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DepthFunc) {
+ DepthFunc& cmd = *GetBufferAs<DepthFunc>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(DepthFunc::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DepthMask) {
- DepthMask cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DepthMask) {
+ DepthMask& cmd = *GetBufferAs<DepthMask>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLboolean>(11));
EXPECT_EQ(static_cast<uint32>(DepthMask::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLboolean>(11), cmd.flag);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DepthRangef) {
- DepthRangef cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DepthRangef) {
+ DepthRangef& cmd = *GetBufferAs<DepthRangef>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
@@ -818,14 +808,14 @@ TEST(GLES2FormatTest, DepthRangef) {
EXPECT_EQ(static_cast<uint32>(DepthRangef::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DetachShader) {
- DetachShader cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DetachShader) {
+ DetachShader& cmd = *GetBufferAs<DetachShader>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -833,40 +823,40 @@ TEST(GLES2FormatTest, DetachShader) {
EXPECT_EQ(static_cast<uint32>(DetachShader::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Disable) {
- Disable cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Disable) {
+ Disable& cmd = *GetBufferAs<Disable>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(Disable::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DisableVertexAttribArray) {
- DisableVertexAttribArray cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DisableVertexAttribArray) {
+ DisableVertexAttribArray& cmd = *GetBufferAs<DisableVertexAttribArray>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(DisableVertexAttribArray::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DrawArrays) {
- DrawArrays cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DrawArrays) {
+ DrawArrays& cmd = *GetBufferAs<DrawArrays>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -875,15 +865,15 @@ TEST(GLES2FormatTest, DrawArrays) {
EXPECT_EQ(static_cast<uint32>(DrawArrays::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DrawElements) {
- DrawElements cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DrawElements) {
+ DrawElements& cmd = *GetBufferAs<DrawElements>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -893,64 +883,64 @@ TEST(GLES2FormatTest, DrawElements) {
EXPECT_EQ(static_cast<uint32>(DrawElements::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Enable) {
- Enable cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Enable) {
+ Enable& cmd = *GetBufferAs<Enable>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(Enable::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, EnableVertexAttribArray) {
- EnableVertexAttribArray cmd = { { 0 } };
+TEST_F(GLES2FormatTest, EnableVertexAttribArray) {
+ EnableVertexAttribArray& cmd = *GetBufferAs<EnableVertexAttribArray>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(EnableVertexAttribArray::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Finish) {
- Finish cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Finish) {
+ Finish& cmd = *GetBufferAs<Finish>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(Finish::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Flush) {
- Flush cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Flush) {
+ Flush& cmd = *GetBufferAs<Flush>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(Flush::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, FramebufferRenderbuffer) {
- FramebufferRenderbuffer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, FramebufferRenderbuffer) {
+ FramebufferRenderbuffer& cmd = *GetBufferAs<FramebufferRenderbuffer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -960,16 +950,16 @@ TEST(GLES2FormatTest, FramebufferRenderbuffer) {
EXPECT_EQ(static_cast<uint32>(FramebufferRenderbuffer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLuint>(14), cmd.renderbuffer);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, FramebufferTexture2D) {
- FramebufferTexture2D cmd = { { 0 } };
+TEST_F(GLES2FormatTest, FramebufferTexture2D) {
+ FramebufferTexture2D& cmd = *GetBufferAs<FramebufferTexture2D>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -980,30 +970,30 @@ TEST(GLES2FormatTest, FramebufferTexture2D) {
EXPECT_EQ(static_cast<uint32>(FramebufferTexture2D::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
EXPECT_EQ(static_cast<GLint>(15), cmd.level);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, FrontFace) {
- FrontFace cmd = { { 0 } };
+TEST_F(GLES2FormatTest, FrontFace) {
+ FrontFace& cmd = *GetBufferAs<FrontFace>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(FrontFace::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GenBuffers) {
- GenBuffers cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GenBuffers) {
+ GenBuffers& cmd = *GetBufferAs<GenBuffers>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -1012,49 +1002,45 @@ TEST(GLES2FormatTest, GenBuffers) {
EXPECT_EQ(static_cast<uint32>(GenBuffers::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GenBuffersImmediate) {
+TEST_F(GLES2FormatTest, GenBuffersImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
- GenBuffersImmediate& cmd =
- *static_cast<GenBuffersImmediate*>(static_cast<void*>(&buf));
+ GenBuffersImmediate& cmd = *GetBufferAs<GenBuffersImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(GenBuffersImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, GenerateMipmap) {
- GenerateMipmap cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GenerateMipmap) {
+ GenerateMipmap& cmd = *GetBufferAs<GenerateMipmap>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11));
EXPECT_EQ(static_cast<uint32>(GenerateMipmap::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GenFramebuffers) {
- GenFramebuffers cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GenFramebuffers) {
+ GenFramebuffers& cmd = *GetBufferAs<GenFramebuffers>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -1063,36 +1049,32 @@ TEST(GLES2FormatTest, GenFramebuffers) {
EXPECT_EQ(static_cast<uint32>(GenFramebuffers::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GenFramebuffersImmediate) {
+TEST_F(GLES2FormatTest, GenFramebuffersImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
- GenFramebuffersImmediate& cmd =
- *static_cast<GenFramebuffersImmediate*>(static_cast<void*>(&buf));
+ GenFramebuffersImmediate& cmd = *GetBufferAs<GenFramebuffersImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(GenFramebuffersImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, GenRenderbuffers) {
- GenRenderbuffers cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GenRenderbuffers) {
+ GenRenderbuffers& cmd = *GetBufferAs<GenRenderbuffers>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -1101,36 +1083,32 @@ TEST(GLES2FormatTest, GenRenderbuffers) {
EXPECT_EQ(static_cast<uint32>(GenRenderbuffers::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GenRenderbuffersImmediate) {
+TEST_F(GLES2FormatTest, GenRenderbuffersImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
- GenRenderbuffersImmediate& cmd =
- *static_cast<GenRenderbuffersImmediate*>(static_cast<void*>(&buf));
+ GenRenderbuffersImmediate& cmd = *GetBufferAs<GenRenderbuffersImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(GenRenderbuffersImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, GenTextures) {
- GenTextures cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GenTextures) {
+ GenTextures& cmd = *GetBufferAs<GenTextures>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -1139,36 +1117,32 @@ TEST(GLES2FormatTest, GenTextures) {
EXPECT_EQ(static_cast<uint32>(GenTextures::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GenTexturesImmediate) {
+TEST_F(GLES2FormatTest, GenTexturesImmediate) {
static GLuint ids[] = { 12, 23, 34, };
- int8 buf[256] = { 0, };
- GenTexturesImmediate& cmd =
- *static_cast<GenTexturesImmediate*>(static_cast<void*>(&buf));
+ GenTexturesImmediate& cmd = *GetBufferAs<GenTexturesImmediate>();
void* next_cmd = cmd.Set(
- &cmd,
- static_cast<GLsizei>(11),
- ids);
+ &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
EXPECT_EQ(static_cast<uint32>(GenTexturesImmediate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(cmd.n * 4u),
cmd.header.size * 4u);
- 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);
+ EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
// TODO(gman): Check that ids were inserted;
}
-TEST(GLES2FormatTest, GetActiveAttrib) {
- GetActiveAttrib cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetActiveAttrib) {
+ GetActiveAttrib& cmd = *GetBufferAs<GetActiveAttrib>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1179,17 +1153,17 @@ TEST(GLES2FormatTest, GetActiveAttrib) {
EXPECT_EQ(static_cast<uint32>(GetActiveAttrib::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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_bucket_id);
EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetActiveUniform) {
- GetActiveUniform cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetActiveUniform) {
+ GetActiveUniform& cmd = *GetBufferAs<GetActiveUniform>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1200,17 +1174,17 @@ TEST(GLES2FormatTest, GetActiveUniform) {
EXPECT_EQ(static_cast<uint32>(GetActiveUniform::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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_bucket_id);
EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetAttachedShaders) {
- GetAttachedShaders cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetAttachedShaders) {
+ GetAttachedShaders& cmd = *GetBufferAs<GetAttachedShaders>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1220,19 +1194,19 @@ TEST(GLES2FormatTest, GetAttachedShaders) {
EXPECT_EQ(static_cast<uint32>(GetAttachedShaders::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.result_size);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Write test for GetAttribLocation
// TODO(gman): Write test for GetAttribLocationImmediate
// TODO(gman): Write test for GetAttribLocationBucket
-TEST(GLES2FormatTest, GetBooleanv) {
- GetBooleanv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetBooleanv) {
+ GetBooleanv& cmd = *GetBufferAs<GetBooleanv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1241,15 +1215,15 @@ TEST(GLES2FormatTest, GetBooleanv) {
EXPECT_EQ(static_cast<uint32>(GetBooleanv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetBufferParameteriv) {
- GetBufferParameteriv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetBufferParameteriv) {
+ GetBufferParameteriv& cmd = *GetBufferAs<GetBufferParameteriv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1259,16 +1233,16 @@ TEST(GLES2FormatTest, GetBufferParameteriv) {
EXPECT_EQ(static_cast<uint32>(GetBufferParameteriv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetError) {
- GetError cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetError) {
+ GetError& cmd = *GetBufferAs<GetError>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<uint32>(11),
@@ -1276,14 +1250,14 @@ TEST(GLES2FormatTest, GetError) {
EXPECT_EQ(static_cast<uint32>(GetError::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetFloatv) {
- GetFloatv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetFloatv) {
+ GetFloatv& cmd = *GetBufferAs<GetFloatv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1292,15 +1266,16 @@ TEST(GLES2FormatTest, GetFloatv) {
EXPECT_EQ(static_cast<uint32>(GetFloatv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
- GetFramebufferAttachmentParameteriv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
+ GetFramebufferAttachmentParameteriv& cmd =
+ *GetBufferAs<GetFramebufferAttachmentParameteriv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1311,17 +1286,17 @@ TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
EXPECT_EQ(static_cast<uint32>(GetFramebufferAttachmentParameteriv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetIntegerv) {
- GetIntegerv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetIntegerv) {
+ GetIntegerv& cmd = *GetBufferAs<GetIntegerv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1330,15 +1305,15 @@ TEST(GLES2FormatTest, GetIntegerv) {
EXPECT_EQ(static_cast<uint32>(GetIntegerv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetProgramiv) {
- GetProgramiv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetProgramiv) {
+ GetProgramiv& cmd = *GetBufferAs<GetProgramiv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1348,16 +1323,16 @@ TEST(GLES2FormatTest, GetProgramiv) {
EXPECT_EQ(static_cast<uint32>(GetProgramiv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetProgramInfoLog) {
- GetProgramInfoLog cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetProgramInfoLog) {
+ GetProgramInfoLog& cmd = *GetBufferAs<GetProgramInfoLog>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1365,14 +1340,14 @@ TEST(GLES2FormatTest, GetProgramInfoLog) {
EXPECT_EQ(static_cast<uint32>(GetProgramInfoLog::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetRenderbufferParameteriv) {
- GetRenderbufferParameteriv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetRenderbufferParameteriv) {
+ GetRenderbufferParameteriv& cmd = *GetBufferAs<GetRenderbufferParameteriv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1382,16 +1357,16 @@ TEST(GLES2FormatTest, GetRenderbufferParameteriv) {
EXPECT_EQ(static_cast<uint32>(GetRenderbufferParameteriv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetShaderiv) {
- GetShaderiv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetShaderiv) {
+ GetShaderiv& cmd = *GetBufferAs<GetShaderiv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1401,16 +1376,16 @@ TEST(GLES2FormatTest, GetShaderiv) {
EXPECT_EQ(static_cast<uint32>(GetShaderiv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetShaderInfoLog) {
- GetShaderInfoLog cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetShaderInfoLog) {
+ GetShaderInfoLog& cmd = *GetBufferAs<GetShaderInfoLog>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1418,14 +1393,14 @@ TEST(GLES2FormatTest, GetShaderInfoLog) {
EXPECT_EQ(static_cast<uint32>(GetShaderInfoLog::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetShaderPrecisionFormat) {
- GetShaderPrecisionFormat cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetShaderPrecisionFormat) {
+ GetShaderPrecisionFormat& cmd = *GetBufferAs<GetShaderPrecisionFormat>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1435,16 +1410,16 @@ TEST(GLES2FormatTest, GetShaderPrecisionFormat) {
EXPECT_EQ(static_cast<uint32>(GetShaderPrecisionFormat::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.result_shm_id);
EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetShaderSource) {
- GetShaderSource cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetShaderSource) {
+ GetShaderSource& cmd = *GetBufferAs<GetShaderSource>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1452,14 +1427,14 @@ TEST(GLES2FormatTest, GetShaderSource) {
EXPECT_EQ(static_cast<uint32>(GetShaderSource::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetString) {
- GetString cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetString) {
+ GetString& cmd = *GetBufferAs<GetString>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1467,14 +1442,14 @@ TEST(GLES2FormatTest, GetString) {
EXPECT_EQ(static_cast<uint32>(GetString::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLenum>(11), cmd.name);
EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetTexParameterfv) {
- GetTexParameterfv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetTexParameterfv) {
+ GetTexParameterfv& cmd = *GetBufferAs<GetTexParameterfv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1484,16 +1459,16 @@ TEST(GLES2FormatTest, GetTexParameterfv) {
EXPECT_EQ(static_cast<uint32>(GetTexParameterfv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetTexParameteriv) {
- GetTexParameteriv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetTexParameteriv) {
+ GetTexParameteriv& cmd = *GetBufferAs<GetTexParameteriv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1503,16 +1478,16 @@ TEST(GLES2FormatTest, GetTexParameteriv) {
EXPECT_EQ(static_cast<uint32>(GetTexParameteriv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetUniformfv) {
- GetUniformfv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetUniformfv) {
+ GetUniformfv& cmd = *GetBufferAs<GetUniformfv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1522,16 +1497,16 @@ TEST(GLES2FormatTest, GetUniformfv) {
EXPECT_EQ(static_cast<uint32>(GetUniformfv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetUniformiv) {
- GetUniformiv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetUniformiv) {
+ GetUniformiv& cmd = *GetBufferAs<GetUniformiv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1541,19 +1516,19 @@ TEST(GLES2FormatTest, GetUniformiv) {
EXPECT_EQ(static_cast<uint32>(GetUniformiv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Write test for GetUniformLocation
// TODO(gman): Write test for GetUniformLocationImmediate
// TODO(gman): Write test for GetUniformLocationBucket
-TEST(GLES2FormatTest, GetVertexAttribfv) {
- GetVertexAttribfv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetVertexAttribfv) {
+ GetVertexAttribfv& cmd = *GetBufferAs<GetVertexAttribfv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1563,16 +1538,16 @@ TEST(GLES2FormatTest, GetVertexAttribfv) {
EXPECT_EQ(static_cast<uint32>(GetVertexAttribfv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetVertexAttribiv) {
- GetVertexAttribiv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetVertexAttribiv) {
+ GetVertexAttribiv& cmd = *GetBufferAs<GetVertexAttribiv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1582,16 +1557,16 @@ TEST(GLES2FormatTest, GetVertexAttribiv) {
EXPECT_EQ(static_cast<uint32>(GetVertexAttribiv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetVertexAttribPointerv) {
- GetVertexAttribPointerv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetVertexAttribPointerv) {
+ GetVertexAttribPointerv& cmd = *GetBufferAs<GetVertexAttribPointerv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1601,16 +1576,16 @@ TEST(GLES2FormatTest, GetVertexAttribPointerv) {
EXPECT_EQ(static_cast<uint32>(GetVertexAttribPointerv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.pointer_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Hint) {
- Hint cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Hint) {
+ Hint& cmd = *GetBufferAs<Hint>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1618,14 +1593,14 @@ TEST(GLES2FormatTest, Hint) {
EXPECT_EQ(static_cast<uint32>(Hint::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, IsBuffer) {
- IsBuffer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, IsBuffer) {
+ IsBuffer& cmd = *GetBufferAs<IsBuffer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1634,15 +1609,15 @@ TEST(GLES2FormatTest, IsBuffer) {
EXPECT_EQ(static_cast<uint32>(IsBuffer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, IsEnabled) {
- IsEnabled cmd = { { 0 } };
+TEST_F(GLES2FormatTest, IsEnabled) {
+ IsEnabled& cmd = *GetBufferAs<IsEnabled>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1651,15 +1626,15 @@ TEST(GLES2FormatTest, IsEnabled) {
EXPECT_EQ(static_cast<uint32>(IsEnabled::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, IsFramebuffer) {
- IsFramebuffer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, IsFramebuffer) {
+ IsFramebuffer& cmd = *GetBufferAs<IsFramebuffer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1668,15 +1643,15 @@ TEST(GLES2FormatTest, IsFramebuffer) {
EXPECT_EQ(static_cast<uint32>(IsFramebuffer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, IsProgram) {
- IsProgram cmd = { { 0 } };
+TEST_F(GLES2FormatTest, IsProgram) {
+ IsProgram& cmd = *GetBufferAs<IsProgram>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1685,15 +1660,15 @@ TEST(GLES2FormatTest, IsProgram) {
EXPECT_EQ(static_cast<uint32>(IsProgram::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, IsRenderbuffer) {
- IsRenderbuffer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, IsRenderbuffer) {
+ IsRenderbuffer& cmd = *GetBufferAs<IsRenderbuffer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1702,15 +1677,15 @@ TEST(GLES2FormatTest, IsRenderbuffer) {
EXPECT_EQ(static_cast<uint32>(IsRenderbuffer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, IsShader) {
- IsShader cmd = { { 0 } };
+TEST_F(GLES2FormatTest, IsShader) {
+ IsShader& cmd = *GetBufferAs<IsShader>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1719,15 +1694,15 @@ TEST(GLES2FormatTest, IsShader) {
EXPECT_EQ(static_cast<uint32>(IsShader::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, IsTexture) {
- IsTexture cmd = { { 0 } };
+TEST_F(GLES2FormatTest, IsTexture) {
+ IsTexture& cmd = *GetBufferAs<IsTexture>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1736,41 +1711,41 @@ TEST(GLES2FormatTest, IsTexture) {
EXPECT_EQ(static_cast<uint32>(IsTexture::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, LineWidth) {
- LineWidth cmd = { { 0 } };
+TEST_F(GLES2FormatTest, LineWidth) {
+ LineWidth& cmd = *GetBufferAs<LineWidth>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLfloat>(11));
EXPECT_EQ(static_cast<uint32>(LineWidth::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLfloat>(11), cmd.width);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, LinkProgram) {
- LinkProgram cmd = { { 0 } };
+TEST_F(GLES2FormatTest, LinkProgram) {
+ LinkProgram& cmd = *GetBufferAs<LinkProgram>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(LinkProgram::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, PixelStorei) {
- PixelStorei cmd = { { 0 } };
+TEST_F(GLES2FormatTest, PixelStorei) {
+ PixelStorei& cmd = *GetBufferAs<PixelStorei>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1778,14 +1753,14 @@ TEST(GLES2FormatTest, PixelStorei) {
EXPECT_EQ(static_cast<uint32>(PixelStorei::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, PolygonOffset) {
- PolygonOffset cmd = { { 0 } };
+TEST_F(GLES2FormatTest, PolygonOffset) {
+ PolygonOffset& cmd = *GetBufferAs<PolygonOffset>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLfloat>(11),
@@ -1793,14 +1768,14 @@ TEST(GLES2FormatTest, PolygonOffset) {
EXPECT_EQ(static_cast<uint32>(PolygonOffset::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ReadPixels) {
- ReadPixels cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ReadPixels) {
+ ReadPixels& cmd = *GetBufferAs<ReadPixels>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -1816,8 +1791,6 @@ TEST(GLES2FormatTest, ReadPixels) {
EXPECT_EQ(static_cast<uint32>(ReadPixels::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -1828,21 +1801,23 @@ TEST(GLES2FormatTest, ReadPixels) {
EXPECT_EQ(static_cast<uint32>(18), cmd.pixels_shm_offset);
EXPECT_EQ(static_cast<uint32>(19), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(20), cmd.result_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ReleaseShaderCompiler) {
- ReleaseShaderCompiler cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ReleaseShaderCompiler) {
+ ReleaseShaderCompiler& cmd = *GetBufferAs<ReleaseShaderCompiler>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(ReleaseShaderCompiler::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, RenderbufferStorage) {
- RenderbufferStorage cmd = { { 0 } };
+TEST_F(GLES2FormatTest, RenderbufferStorage) {
+ RenderbufferStorage& cmd = *GetBufferAs<RenderbufferStorage>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1852,16 +1827,16 @@ TEST(GLES2FormatTest, RenderbufferStorage) {
EXPECT_EQ(static_cast<uint32>(RenderbufferStorage::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, SampleCoverage) {
- SampleCoverage cmd = { { 0 } };
+TEST_F(GLES2FormatTest, SampleCoverage) {
+ SampleCoverage& cmd = *GetBufferAs<SampleCoverage>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLclampf>(11),
@@ -1869,14 +1844,14 @@ TEST(GLES2FormatTest, SampleCoverage) {
EXPECT_EQ(static_cast<uint32>(SampleCoverage::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Scissor) {
- Scissor cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Scissor) {
+ Scissor& cmd = *GetBufferAs<Scissor>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -1886,16 +1861,16 @@ TEST(GLES2FormatTest, Scissor) {
EXPECT_EQ(static_cast<uint32>(Scissor::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ShaderBinary) {
- ShaderBinary cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ShaderBinary) {
+ ShaderBinary& cmd = *GetBufferAs<ShaderBinary>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLsizei>(11),
@@ -1908,8 +1883,6 @@ TEST(GLES2FormatTest, ShaderBinary) {
EXPECT_EQ(static_cast<uint32>(ShaderBinary::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.shaders_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.shaders_shm_offset);
@@ -1917,10 +1890,12 @@ TEST(GLES2FormatTest, ShaderBinary) {
EXPECT_EQ(static_cast<uint32>(15), cmd.binary_shm_id);
EXPECT_EQ(static_cast<uint32>(16), cmd.binary_shm_offset);
EXPECT_EQ(static_cast<GLsizei>(17), cmd.length);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ShaderSource) {
- ShaderSource cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ShaderSource) {
+ ShaderSource& cmd = *GetBufferAs<ShaderSource>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1930,17 +1905,17 @@ TEST(GLES2FormatTest, ShaderSource) {
EXPECT_EQ(static_cast<uint32>(ShaderSource::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.data_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_offset);
EXPECT_EQ(static_cast<uint32>(14), cmd.data_size);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Implement test for ShaderSourceImmediate
-TEST(GLES2FormatTest, ShaderSourceBucket) {
- ShaderSourceBucket cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ShaderSourceBucket) {
+ ShaderSourceBucket& cmd = *GetBufferAs<ShaderSourceBucket>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -1948,14 +1923,14 @@ TEST(GLES2FormatTest, ShaderSourceBucket) {
EXPECT_EQ(static_cast<uint32>(ShaderSourceBucket::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.data_bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, StencilFunc) {
- StencilFunc cmd = { { 0 } };
+TEST_F(GLES2FormatTest, StencilFunc) {
+ StencilFunc& cmd = *GetBufferAs<StencilFunc>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1964,15 +1939,15 @@ TEST(GLES2FormatTest, StencilFunc) {
EXPECT_EQ(static_cast<uint32>(StencilFunc::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, StencilFuncSeparate) {
- StencilFuncSeparate cmd = { { 0 } };
+TEST_F(GLES2FormatTest, StencilFuncSeparate) {
+ StencilFuncSeparate& cmd = *GetBufferAs<StencilFuncSeparate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -1982,29 +1957,29 @@ TEST(GLES2FormatTest, StencilFuncSeparate) {
EXPECT_EQ(static_cast<uint32>(StencilFuncSeparate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLuint>(14), cmd.mask);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, StencilMask) {
- StencilMask cmd = { { 0 } };
+TEST_F(GLES2FormatTest, StencilMask) {
+ StencilMask& cmd = *GetBufferAs<StencilMask>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(StencilMask::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.mask);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, StencilMaskSeparate) {
- StencilMaskSeparate cmd = { { 0 } };
+TEST_F(GLES2FormatTest, StencilMaskSeparate) {
+ StencilMaskSeparate& cmd = *GetBufferAs<StencilMaskSeparate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2012,14 +1987,14 @@ TEST(GLES2FormatTest, StencilMaskSeparate) {
EXPECT_EQ(static_cast<uint32>(StencilMaskSeparate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, StencilOp) {
- StencilOp cmd = { { 0 } };
+TEST_F(GLES2FormatTest, StencilOp) {
+ StencilOp& cmd = *GetBufferAs<StencilOp>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2028,15 +2003,15 @@ TEST(GLES2FormatTest, StencilOp) {
EXPECT_EQ(static_cast<uint32>(StencilOp::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, StencilOpSeparate) {
- StencilOpSeparate cmd = { { 0 } };
+TEST_F(GLES2FormatTest, StencilOpSeparate) {
+ StencilOpSeparate& cmd = *GetBufferAs<StencilOpSeparate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2046,16 +2021,16 @@ TEST(GLES2FormatTest, StencilOpSeparate) {
EXPECT_EQ(static_cast<uint32>(StencilOpSeparate::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLenum>(14), cmd.zpass);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, TexImage2D) {
- TexImage2D cmd = { { 0 } };
+TEST_F(GLES2FormatTest, TexImage2D) {
+ TexImage2D& cmd = *GetBufferAs<TexImage2D>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2071,8 +2046,6 @@ TEST(GLES2FormatTest, TexImage2D) {
EXPECT_EQ(static_cast<uint32>(TexImage2D::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -2083,11 +2056,13 @@ TEST(GLES2FormatTest, TexImage2D) {
EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Implement test for TexImage2DImmediate
-TEST(GLES2FormatTest, TexParameterf) {
- TexParameterf cmd = { { 0 } };
+TEST_F(GLES2FormatTest, TexParameterf) {
+ TexParameterf& cmd = *GetBufferAs<TexParameterf>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2096,15 +2071,15 @@ TEST(GLES2FormatTest, TexParameterf) {
EXPECT_EQ(static_cast<uint32>(TexParameterf::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, TexParameterfv) {
- TexParameterfv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, TexParameterfv) {
+ TexParameterfv& cmd = *GetBufferAs<TexParameterfv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2114,22 +2089,20 @@ TEST(GLES2FormatTest, TexParameterfv) {
EXPECT_EQ(static_cast<uint32>(TexParameterfv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, TexParameterfvImmediate) {
+TEST_F(GLES2FormatTest, TexParameterfvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
};
- int8 buf[256] = { 0, };
- TexParameterfvImmediate& cmd =
- *static_cast<TexParameterfvImmediate*>(static_cast<void*>(&buf));
+ TexParameterfvImmediate& cmd = *GetBufferAs<TexParameterfvImmediate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2140,16 +2113,16 @@ TEST(GLES2FormatTest, TexParameterfvImmediate) {
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, TexParameteri) {
- TexParameteri cmd = { { 0 } };
+TEST_F(GLES2FormatTest, TexParameteri) {
+ TexParameteri& cmd = *GetBufferAs<TexParameteri>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2158,15 +2131,15 @@ TEST(GLES2FormatTest, TexParameteri) {
EXPECT_EQ(static_cast<uint32>(TexParameteri::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, TexParameteriv) {
- TexParameteriv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, TexParameteriv) {
+ TexParameteriv& cmd = *GetBufferAs<TexParameteriv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2176,22 +2149,20 @@ TEST(GLES2FormatTest, TexParameteriv) {
EXPECT_EQ(static_cast<uint32>(TexParameteriv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, TexParameterivImmediate) {
+TEST_F(GLES2FormatTest, TexParameterivImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLint data[] = {
static_cast<GLint>(kSomeBaseValueToTestWith + 0),
};
- int8 buf[256] = { 0, };
- TexParameterivImmediate& cmd =
- *static_cast<TexParameterivImmediate*>(static_cast<void*>(&buf));
+ TexParameterivImmediate& cmd = *GetBufferAs<TexParameterivImmediate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2202,16 +2173,16 @@ TEST(GLES2FormatTest, TexParameterivImmediate) {
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, TexSubImage2D) {
- TexSubImage2D cmd = { { 0 } };
+TEST_F(GLES2FormatTest, TexSubImage2D) {
+ TexSubImage2D& cmd = *GetBufferAs<TexSubImage2D>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -2228,8 +2199,6 @@ TEST(GLES2FormatTest, TexSubImage2D) {
EXPECT_EQ(static_cast<uint32>(TexSubImage2D::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
@@ -2241,11 +2210,13 @@ TEST(GLES2FormatTest, TexSubImage2D) {
EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
EXPECT_EQ(static_cast<GLboolean>(21), cmd.internal);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
// TODO(gman): Implement test for TexSubImage2DImmediate
-TEST(GLES2FormatTest, Uniform1f) {
- Uniform1f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform1f) {
+ Uniform1f& cmd = *GetBufferAs<Uniform1f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2253,14 +2224,14 @@ TEST(GLES2FormatTest, Uniform1f) {
EXPECT_EQ(static_cast<uint32>(Uniform1f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform1fv) {
- Uniform1fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform1fv) {
+ Uniform1fv& cmd = *GetBufferAs<Uniform1fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2270,23 +2241,24 @@ TEST(GLES2FormatTest, Uniform1fv) {
EXPECT_EQ(static_cast<uint32>(Uniform1fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform1fvImmediate) {
+TEST_F(GLES2FormatTest, Uniform1fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
};
- int8 buf[256] = { 0, };
- Uniform1fvImmediate& cmd =
- *static_cast<Uniform1fvImmediate*>(static_cast<void*>(&buf));
+ Uniform1fvImmediate& cmd = *GetBufferAs<Uniform1fvImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLfloat) * 1;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2294,19 +2266,17 @@ TEST(GLES2FormatTest, Uniform1fvImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform1fvImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, Uniform1i) {
- Uniform1i cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform1i) {
+ Uniform1i& cmd = *GetBufferAs<Uniform1i>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2314,14 +2284,14 @@ TEST(GLES2FormatTest, Uniform1i) {
EXPECT_EQ(static_cast<uint32>(Uniform1i::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform1iv) {
- Uniform1iv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform1iv) {
+ Uniform1iv& cmd = *GetBufferAs<Uniform1iv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2331,23 +2301,24 @@ TEST(GLES2FormatTest, Uniform1iv) {
EXPECT_EQ(static_cast<uint32>(Uniform1iv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform1ivImmediate) {
+TEST_F(GLES2FormatTest, Uniform1ivImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLint data[] = {
static_cast<GLint>(kSomeBaseValueToTestWith + 0),
static_cast<GLint>(kSomeBaseValueToTestWith + 1),
};
- int8 buf[256] = { 0, };
- Uniform1ivImmediate& cmd =
- *static_cast<Uniform1ivImmediate*>(static_cast<void*>(&buf));
+ Uniform1ivImmediate& cmd = *GetBufferAs<Uniform1ivImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLint) * 1;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2355,19 +2326,17 @@ TEST(GLES2FormatTest, Uniform1ivImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform1ivImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, Uniform2f) {
- Uniform2f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform2f) {
+ Uniform2f& cmd = *GetBufferAs<Uniform2f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2376,15 +2345,15 @@ TEST(GLES2FormatTest, Uniform2f) {
EXPECT_EQ(static_cast<uint32>(Uniform2f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform2fv) {
- Uniform2fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform2fv) {
+ Uniform2fv& cmd = *GetBufferAs<Uniform2fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2394,15 +2363,15 @@ TEST(GLES2FormatTest, Uniform2fv) {
EXPECT_EQ(static_cast<uint32>(Uniform2fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform2fvImmediate) {
+TEST_F(GLES2FormatTest, Uniform2fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
@@ -2410,9 +2379,10 @@ TEST(GLES2FormatTest, Uniform2fvImmediate) {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
};
- int8 buf[256] = { 0, };
- Uniform2fvImmediate& cmd =
- *static_cast<Uniform2fvImmediate*>(static_cast<void*>(&buf));
+ Uniform2fvImmediate& cmd = *GetBufferAs<Uniform2fvImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLfloat) * 2;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2420,19 +2390,17 @@ TEST(GLES2FormatTest, Uniform2fvImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform2fvImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, Uniform2i) {
- Uniform2i cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform2i) {
+ Uniform2i& cmd = *GetBufferAs<Uniform2i>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2441,15 +2409,15 @@ TEST(GLES2FormatTest, Uniform2i) {
EXPECT_EQ(static_cast<uint32>(Uniform2i::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform2iv) {
- Uniform2iv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform2iv) {
+ Uniform2iv& cmd = *GetBufferAs<Uniform2iv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2459,15 +2427,15 @@ TEST(GLES2FormatTest, Uniform2iv) {
EXPECT_EQ(static_cast<uint32>(Uniform2iv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform2ivImmediate) {
+TEST_F(GLES2FormatTest, Uniform2ivImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLint data[] = {
static_cast<GLint>(kSomeBaseValueToTestWith + 0),
@@ -2475,9 +2443,10 @@ TEST(GLES2FormatTest, Uniform2ivImmediate) {
static_cast<GLint>(kSomeBaseValueToTestWith + 2),
static_cast<GLint>(kSomeBaseValueToTestWith + 3),
};
- int8 buf[256] = { 0, };
- Uniform2ivImmediate& cmd =
- *static_cast<Uniform2ivImmediate*>(static_cast<void*>(&buf));
+ Uniform2ivImmediate& cmd = *GetBufferAs<Uniform2ivImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLint) * 2;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2485,19 +2454,17 @@ TEST(GLES2FormatTest, Uniform2ivImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform2ivImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, Uniform3f) {
- Uniform3f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform3f) {
+ Uniform3f& cmd = *GetBufferAs<Uniform3f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2507,16 +2474,16 @@ TEST(GLES2FormatTest, Uniform3f) {
EXPECT_EQ(static_cast<uint32>(Uniform3f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform3fv) {
- Uniform3fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform3fv) {
+ Uniform3fv& cmd = *GetBufferAs<Uniform3fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2526,15 +2493,15 @@ TEST(GLES2FormatTest, Uniform3fv) {
EXPECT_EQ(static_cast<uint32>(Uniform3fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform3fvImmediate) {
+TEST_F(GLES2FormatTest, Uniform3fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
@@ -2544,9 +2511,10 @@ TEST(GLES2FormatTest, Uniform3fvImmediate) {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
};
- int8 buf[256] = { 0, };
- Uniform3fvImmediate& cmd =
- *static_cast<Uniform3fvImmediate*>(static_cast<void*>(&buf));
+ Uniform3fvImmediate& cmd = *GetBufferAs<Uniform3fvImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLfloat) * 3;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2554,19 +2522,17 @@ TEST(GLES2FormatTest, Uniform3fvImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform3fvImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, Uniform3i) {
- Uniform3i cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform3i) {
+ Uniform3i& cmd = *GetBufferAs<Uniform3i>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2576,16 +2542,16 @@ TEST(GLES2FormatTest, Uniform3i) {
EXPECT_EQ(static_cast<uint32>(Uniform3i::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLint>(14), cmd.z);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform3iv) {
- Uniform3iv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform3iv) {
+ Uniform3iv& cmd = *GetBufferAs<Uniform3iv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2595,15 +2561,15 @@ TEST(GLES2FormatTest, Uniform3iv) {
EXPECT_EQ(static_cast<uint32>(Uniform3iv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform3ivImmediate) {
+TEST_F(GLES2FormatTest, Uniform3ivImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLint data[] = {
static_cast<GLint>(kSomeBaseValueToTestWith + 0),
@@ -2613,9 +2579,10 @@ TEST(GLES2FormatTest, Uniform3ivImmediate) {
static_cast<GLint>(kSomeBaseValueToTestWith + 4),
static_cast<GLint>(kSomeBaseValueToTestWith + 5),
};
- int8 buf[256] = { 0, };
- Uniform3ivImmediate& cmd =
- *static_cast<Uniform3ivImmediate*>(static_cast<void*>(&buf));
+ Uniform3ivImmediate& cmd = *GetBufferAs<Uniform3ivImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLint) * 3;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2623,19 +2590,17 @@ TEST(GLES2FormatTest, Uniform3ivImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform3ivImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, Uniform4f) {
- Uniform4f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform4f) {
+ Uniform4f& cmd = *GetBufferAs<Uniform4f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2646,17 +2611,17 @@ TEST(GLES2FormatTest, Uniform4f) {
EXPECT_EQ(static_cast<uint32>(Uniform4f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform4fv) {
- Uniform4fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform4fv) {
+ Uniform4fv& cmd = *GetBufferAs<Uniform4fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2666,15 +2631,15 @@ TEST(GLES2FormatTest, Uniform4fv) {
EXPECT_EQ(static_cast<uint32>(Uniform4fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform4fvImmediate) {
+TEST_F(GLES2FormatTest, Uniform4fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
@@ -2686,9 +2651,10 @@ TEST(GLES2FormatTest, Uniform4fvImmediate) {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
};
- int8 buf[256] = { 0, };
- Uniform4fvImmediate& cmd =
- *static_cast<Uniform4fvImmediate*>(static_cast<void*>(&buf));
+ Uniform4fvImmediate& cmd = *GetBufferAs<Uniform4fvImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2696,19 +2662,17 @@ TEST(GLES2FormatTest, Uniform4fvImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform4fvImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, Uniform4i) {
- Uniform4i cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform4i) {
+ Uniform4i& cmd = *GetBufferAs<Uniform4i>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2719,17 +2683,17 @@ TEST(GLES2FormatTest, Uniform4i) {
EXPECT_EQ(static_cast<uint32>(Uniform4i::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLint>(14), cmd.z);
EXPECT_EQ(static_cast<GLint>(15), cmd.w);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform4iv) {
- Uniform4iv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Uniform4iv) {
+ Uniform4iv& cmd = *GetBufferAs<Uniform4iv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2739,15 +2703,15 @@ TEST(GLES2FormatTest, Uniform4iv) {
EXPECT_EQ(static_cast<uint32>(Uniform4iv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Uniform4ivImmediate) {
+TEST_F(GLES2FormatTest, Uniform4ivImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLint data[] = {
static_cast<GLint>(kSomeBaseValueToTestWith + 0),
@@ -2759,9 +2723,10 @@ TEST(GLES2FormatTest, Uniform4ivImmediate) {
static_cast<GLint>(kSomeBaseValueToTestWith + 6),
static_cast<GLint>(kSomeBaseValueToTestWith + 7),
};
- int8 buf[256] = { 0, };
- Uniform4ivImmediate& cmd =
- *static_cast<Uniform4ivImmediate*>(static_cast<void*>(&buf));
+ Uniform4ivImmediate& cmd = *GetBufferAs<Uniform4ivImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLint) * 4;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2769,19 +2734,17 @@ TEST(GLES2FormatTest, Uniform4ivImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(Uniform4ivImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, UniformMatrix2fv) {
- UniformMatrix2fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, UniformMatrix2fv) {
+ UniformMatrix2fv& cmd = *GetBufferAs<UniformMatrix2fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2792,16 +2755,16 @@ TEST(GLES2FormatTest, UniformMatrix2fv) {
EXPECT_EQ(static_cast<uint32>(UniformMatrix2fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, UniformMatrix2fvImmediate) {
+TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
@@ -2813,9 +2776,10 @@ TEST(GLES2FormatTest, UniformMatrix2fvImmediate) {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
};
- int8 buf[256] = { 0, };
- UniformMatrix2fvImmediate& cmd =
- *static_cast<UniformMatrix2fvImmediate*>(static_cast<void*>(&buf));
+ UniformMatrix2fvImmediate& cmd = *GetBufferAs<UniformMatrix2fvImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2824,20 +2788,18 @@ TEST(GLES2FormatTest, UniformMatrix2fvImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(UniformMatrix2fvImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, UniformMatrix3fv) {
- UniformMatrix3fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, UniformMatrix3fv) {
+ UniformMatrix3fv& cmd = *GetBufferAs<UniformMatrix3fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2848,16 +2810,16 @@ TEST(GLES2FormatTest, UniformMatrix3fv) {
EXPECT_EQ(static_cast<uint32>(UniformMatrix3fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, UniformMatrix3fvImmediate) {
+TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
@@ -2879,9 +2841,10 @@ TEST(GLES2FormatTest, UniformMatrix3fvImmediate) {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 16),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 17),
};
- int8 buf[256] = { 0, };
- UniformMatrix3fvImmediate& cmd =
- *static_cast<UniformMatrix3fvImmediate*>(static_cast<void*>(&buf));
+ UniformMatrix3fvImmediate& cmd = *GetBufferAs<UniformMatrix3fvImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLfloat) * 9;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2890,20 +2853,18 @@ TEST(GLES2FormatTest, UniformMatrix3fvImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(UniformMatrix3fvImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, UniformMatrix4fv) {
- UniformMatrix4fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, UniformMatrix4fv) {
+ UniformMatrix4fv& cmd = *GetBufferAs<UniformMatrix4fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -2914,16 +2875,16 @@ TEST(GLES2FormatTest, UniformMatrix4fv) {
EXPECT_EQ(static_cast<uint32>(UniformMatrix4fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, UniformMatrix4fvImmediate) {
+TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
@@ -2959,9 +2920,10 @@ TEST(GLES2FormatTest, UniformMatrix4fvImmediate) {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 30),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 31),
};
- int8 buf[256] = { 0, };
- UniformMatrix4fvImmediate& cmd =
- *static_cast<UniformMatrix4fvImmediate*>(static_cast<void*>(&buf));
+ UniformMatrix4fvImmediate& cmd = *GetBufferAs<UniformMatrix4fvImmediate>();
+ const GLsizei kNumElements = 2;
+ const size_t kExpectedCmdSize =
+ sizeof(cmd) + kNumElements * sizeof(GLfloat) * 16;
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(1),
@@ -2970,46 +2932,44 @@ TEST(GLES2FormatTest, UniformMatrix4fvImmediate) {
data);
EXPECT_EQ(static_cast<uint32>(UniformMatrix4fvImmediate::kCmdId),
cmd.header.command);
- EXPECT_EQ(sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)),
- cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
+ EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
EXPECT_EQ(static_cast<GLint>(1), cmd.location);
EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, UseProgram) {
- UseProgram cmd = { { 0 } };
+TEST_F(GLES2FormatTest, UseProgram) {
+ UseProgram& cmd = *GetBufferAs<UseProgram>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(UseProgram::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ValidateProgram) {
- ValidateProgram cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ValidateProgram) {
+ ValidateProgram& cmd = *GetBufferAs<ValidateProgram>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11));
EXPECT_EQ(static_cast<uint32>(ValidateProgram::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib1f) {
- VertexAttrib1f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib1f) {
+ VertexAttrib1f& cmd = *GetBufferAs<VertexAttrib1f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3017,14 +2977,14 @@ TEST(GLES2FormatTest, VertexAttrib1f) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib1f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib1fv) {
- VertexAttrib1fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib1fv) {
+ VertexAttrib1fv& cmd = *GetBufferAs<VertexAttrib1fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3033,21 +2993,19 @@ TEST(GLES2FormatTest, VertexAttrib1fv) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib1fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib1fvImmediate) {
+TEST_F(GLES2FormatTest, VertexAttrib1fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
};
- int8 buf[256] = { 0, };
- VertexAttrib1fvImmediate& cmd =
- *static_cast<VertexAttrib1fvImmediate*>(static_cast<void*>(&buf));
+ VertexAttrib1fvImmediate& cmd = *GetBufferAs<VertexAttrib1fvImmediate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3057,15 +3015,15 @@ TEST(GLES2FormatTest, VertexAttrib1fvImmediate) {
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, VertexAttrib2f) {
- VertexAttrib2f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib2f) {
+ VertexAttrib2f& cmd = *GetBufferAs<VertexAttrib2f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3074,15 +3032,15 @@ TEST(GLES2FormatTest, VertexAttrib2f) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib2f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib2fv) {
- VertexAttrib2fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib2fv) {
+ VertexAttrib2fv& cmd = *GetBufferAs<VertexAttrib2fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3091,22 +3049,20 @@ TEST(GLES2FormatTest, VertexAttrib2fv) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib2fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib2fvImmediate) {
+TEST_F(GLES2FormatTest, VertexAttrib2fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
};
- int8 buf[256] = { 0, };
- VertexAttrib2fvImmediate& cmd =
- *static_cast<VertexAttrib2fvImmediate*>(static_cast<void*>(&buf));
+ VertexAttrib2fvImmediate& cmd = *GetBufferAs<VertexAttrib2fvImmediate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3116,15 +3072,15 @@ TEST(GLES2FormatTest, VertexAttrib2fvImmediate) {
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, VertexAttrib3f) {
- VertexAttrib3f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib3f) {
+ VertexAttrib3f& cmd = *GetBufferAs<VertexAttrib3f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3134,16 +3090,16 @@ TEST(GLES2FormatTest, VertexAttrib3f) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib3f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib3fv) {
- VertexAttrib3fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib3fv) {
+ VertexAttrib3fv& cmd = *GetBufferAs<VertexAttrib3fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3152,23 +3108,21 @@ TEST(GLES2FormatTest, VertexAttrib3fv) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib3fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib3fvImmediate) {
+TEST_F(GLES2FormatTest, VertexAttrib3fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
};
- int8 buf[256] = { 0, };
- VertexAttrib3fvImmediate& cmd =
- *static_cast<VertexAttrib3fvImmediate*>(static_cast<void*>(&buf));
+ VertexAttrib3fvImmediate& cmd = *GetBufferAs<VertexAttrib3fvImmediate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3178,15 +3132,15 @@ TEST(GLES2FormatTest, VertexAttrib3fvImmediate) {
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, VertexAttrib4f) {
- VertexAttrib4f cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib4f) {
+ VertexAttrib4f& cmd = *GetBufferAs<VertexAttrib4f>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3197,17 +3151,17 @@ TEST(GLES2FormatTest, VertexAttrib4f) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib4f::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib4fv) {
- VertexAttrib4fv cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttrib4fv) {
+ VertexAttrib4fv& cmd = *GetBufferAs<VertexAttrib4fv>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3216,14 +3170,14 @@ TEST(GLES2FormatTest, VertexAttrib4fv) {
EXPECT_EQ(static_cast<uint32>(VertexAttrib4fv::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, VertexAttrib4fvImmediate) {
+TEST_F(GLES2FormatTest, VertexAttrib4fvImmediate) {
const int kSomeBaseValueToTestWith = 51;
static GLfloat data[] = {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
@@ -3231,9 +3185,7 @@ TEST(GLES2FormatTest, VertexAttrib4fvImmediate) {
static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
};
- int8 buf[256] = { 0, };
- VertexAttrib4fvImmediate& cmd =
- *static_cast<VertexAttrib4fvImmediate*>(static_cast<void*>(&buf));
+ VertexAttrib4fvImmediate& cmd = *GetBufferAs<VertexAttrib4fvImmediate>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3243,15 +3195,15 @@ TEST(GLES2FormatTest, VertexAttrib4fvImmediate) {
EXPECT_EQ(sizeof(cmd) +
RoundSizeToMultipleOfEntries(sizeof(data)),
cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
- RoundSizeToMultipleOfEntries(sizeof(data)));
EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd) +
+ RoundSizeToMultipleOfEntries(sizeof(data)));
// TODO(gman): Check that data was inserted;
}
-TEST(GLES2FormatTest, VertexAttribPointer) {
- VertexAttribPointer cmd = { { 0 } };
+TEST_F(GLES2FormatTest, VertexAttribPointer) {
+ VertexAttribPointer& cmd = *GetBufferAs<VertexAttribPointer>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3263,18 +3215,18 @@ TEST(GLES2FormatTest, VertexAttribPointer) {
EXPECT_EQ(static_cast<uint32>(VertexAttribPointer::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLboolean>(14), cmd.normalized);
EXPECT_EQ(static_cast<GLsizei>(15), cmd.stride);
EXPECT_EQ(static_cast<GLuint>(16), cmd.offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Viewport) {
- Viewport cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Viewport) {
+ Viewport& cmd = *GetBufferAs<Viewport>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -3284,16 +3236,16 @@ TEST(GLES2FormatTest, Viewport) {
EXPECT_EQ(static_cast<uint32>(Viewport::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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);
EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, BlitFramebufferEXT) {
- BlitFramebufferEXT cmd = { { 0 } };
+TEST_F(GLES2FormatTest, BlitFramebufferEXT) {
+ BlitFramebufferEXT& cmd = *GetBufferAs<BlitFramebufferEXT>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLint>(11),
@@ -3309,8 +3261,6 @@ TEST(GLES2FormatTest, BlitFramebufferEXT) {
EXPECT_EQ(static_cast<uint32>(BlitFramebufferEXT::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLint>(11), cmd.srcX0);
EXPECT_EQ(static_cast<GLint>(12), cmd.srcY0);
EXPECT_EQ(static_cast<GLint>(13), cmd.srcX1);
@@ -3321,10 +3271,13 @@ TEST(GLES2FormatTest, BlitFramebufferEXT) {
EXPECT_EQ(static_cast<GLint>(18), cmd.dstY1);
EXPECT_EQ(static_cast<GLbitfield>(19), cmd.mask);
EXPECT_EQ(static_cast<GLenum>(20), cmd.filter);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
- RenderbufferStorageMultisampleEXT cmd = { { 0 } };
+TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
+ RenderbufferStorageMultisampleEXT& cmd =
+ *GetBufferAs<RenderbufferStorageMultisampleEXT>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLenum>(11),
@@ -3335,28 +3288,29 @@ TEST(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
EXPECT_EQ(static_cast<uint32>(RenderbufferStorageMultisampleEXT::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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<GLsizei>(12), cmd.samples);
EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, SwapBuffers) {
- SwapBuffers cmd = { { 0 } };
+TEST_F(GLES2FormatTest, SwapBuffers) {
+ SwapBuffers& cmd = *GetBufferAs<SwapBuffers>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(SwapBuffers::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
- GetMaxValueInBufferCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
+ GetMaxValueInBufferCHROMIUM& cmd =
+ *GetBufferAs<GetMaxValueInBufferCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3368,18 +3322,18 @@ TEST(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(GetMaxValueInBufferCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer_id);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
EXPECT_EQ(static_cast<GLuint>(14), cmd.offset);
EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(16), cmd.result_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GenSharedIdsCHROMIUM) {
- GenSharedIdsCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GenSharedIdsCHROMIUM) {
+ GenSharedIdsCHROMIUM& cmd = *GetBufferAs<GenSharedIdsCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3390,17 +3344,17 @@ TEST(GLES2FormatTest, GenSharedIdsCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(GenSharedIdsCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
EXPECT_EQ(static_cast<GLuint>(12), cmd.id_offset);
EXPECT_EQ(static_cast<GLsizei>(13), cmd.n);
EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.ids_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, DeleteSharedIdsCHROMIUM) {
- DeleteSharedIdsCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, DeleteSharedIdsCHROMIUM) {
+ DeleteSharedIdsCHROMIUM& cmd = *GetBufferAs<DeleteSharedIdsCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3410,16 +3364,16 @@ TEST(GLES2FormatTest, DeleteSharedIdsCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(DeleteSharedIdsCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, RegisterSharedIdsCHROMIUM) {
- RegisterSharedIdsCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, RegisterSharedIdsCHROMIUM) {
+ RegisterSharedIdsCHROMIUM& cmd = *GetBufferAs<RegisterSharedIdsCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3429,16 +3383,16 @@ TEST(GLES2FormatTest, RegisterSharedIdsCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(RegisterSharedIdsCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, EnableFeatureCHROMIUM) {
- EnableFeatureCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, EnableFeatureCHROMIUM) {
+ EnableFeatureCHROMIUM& cmd = *GetBufferAs<EnableFeatureCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3447,15 +3401,15 @@ TEST(GLES2FormatTest, EnableFeatureCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(EnableFeatureCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, ResizeCHROMIUM) {
- ResizeCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, ResizeCHROMIUM) {
+ ResizeCHROMIUM& cmd = *GetBufferAs<ResizeCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3463,40 +3417,42 @@ TEST(GLES2FormatTest, ResizeCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(ResizeCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<GLuint>(11), cmd.width);
EXPECT_EQ(static_cast<GLuint>(12), cmd.height);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) {
- GetRequestableExtensionsCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) {
+ GetRequestableExtensionsCHROMIUM& cmd =
+ *GetBufferAs<GetRequestableExtensionsCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<uint32>(11));
EXPECT_EQ(static_cast<uint32>(GetRequestableExtensionsCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, RequestExtensionCHROMIUM) {
- RequestExtensionCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, RequestExtensionCHROMIUM) {
+ RequestExtensionCHROMIUM& cmd = *GetBufferAs<RequestExtensionCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<uint32>(11));
EXPECT_EQ(static_cast<uint32>(RequestExtensionCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
- GetMultipleIntegervCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
+ GetMultipleIntegervCHROMIUM& cmd =
+ *GetBufferAs<GetMultipleIntegervCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<uint32>(11),
@@ -3508,18 +3464,18 @@ TEST(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(GetMultipleIntegervCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
EXPECT_EQ(static_cast<uint32>(11), cmd.pnames_shm_id);
EXPECT_EQ(static_cast<uint32>(12), cmd.pnames_shm_offset);
EXPECT_EQ(static_cast<GLuint>(13), cmd.count);
EXPECT_EQ(static_cast<uint32>(14), cmd.results_shm_id);
EXPECT_EQ(static_cast<uint32>(15), cmd.results_shm_offset);
EXPECT_EQ(static_cast<GLsizeiptr>(16), cmd.size);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, GetProgramInfoCHROMIUM) {
- GetProgramInfoCHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, GetProgramInfoCHROMIUM) {
+ GetProgramInfoCHROMIUM& cmd = *GetBufferAs<GetProgramInfoCHROMIUM>();
void* next_cmd = cmd.Set(
&cmd,
static_cast<GLuint>(11),
@@ -3527,54 +3483,54 @@ TEST(GLES2FormatTest, GetProgramInfoCHROMIUM) {
EXPECT_EQ(static_cast<uint32>(GetProgramInfoCHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- 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.bucket_id);
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Placeholder447CHROMIUM) {
- Placeholder447CHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Placeholder447CHROMIUM) {
+ Placeholder447CHROMIUM& cmd = *GetBufferAs<Placeholder447CHROMIUM>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(Placeholder447CHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Placeholder451CHROMIUM) {
- Placeholder451CHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Placeholder451CHROMIUM) {
+ Placeholder451CHROMIUM& cmd = *GetBufferAs<Placeholder451CHROMIUM>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(Placeholder451CHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Placeholder452CHROMIUM) {
- Placeholder452CHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Placeholder452CHROMIUM) {
+ Placeholder452CHROMIUM& cmd = *GetBufferAs<Placeholder452CHROMIUM>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(Placeholder452CHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
-TEST(GLES2FormatTest, Placeholder453CHROMIUM) {
- Placeholder453CHROMIUM cmd = { { 0 } };
+TEST_F(GLES2FormatTest, Placeholder453CHROMIUM) {
+ Placeholder453CHROMIUM& cmd = *GetBufferAs<Placeholder453CHROMIUM>();
void* next_cmd = cmd.Set(
&cmd);
EXPECT_EQ(static_cast<uint32>(Placeholder453CHROMIUM::kCmdId),
cmd.header.command);
EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
- EXPECT_EQ(static_cast<char*>(next_cmd),
- reinterpret_cast<char*>(&cmd) + sizeof(cmd));
+ CheckBytesWrittenMatchesExpectedSize(
+ next_cmd, sizeof(cmd));
}
#endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
« no previous file with comments | « gpu/command_buffer/common/gles2_cmd_format_test.cc ('k') | gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698