From 06a62108a4c76a6457ea245a1c88100edac6908e Mon Sep 17 00:00:00 2001 From: "gman@chromium.org" Date: Thu, 8 Sep 2011 07:34:43 +0000 Subject: [PATCH] Fix GPU cmd tests so they pass ASAN TEST=unit tests BUG=95115 R=apatrick@chromium.org Review URL: http://codereview.chromium.org/7789021 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@100116 0039d316-1c4b-4281-b951-d872f2087c98 --- gpu/command_buffer/build_gles2_cmd_buffer.py | 128 +- .../common/gles2_cmd_format_test.cc | 43 +- .../common/gles2_cmd_format_test_autogen.h | 1726 ++++++++--------- .../gles2_cmd_utils_implementation_autogen.h | 4 +- 4 files changed, 925 insertions(+), 976 deletions(-) diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py index 0384acf389c668..f3852202fd73a9 100755 --- a/gpu/command_buffer/build_gles2_cmd_buffer.py +++ b/gpu/command_buffer/build_gles2_cmd_buffer.py @@ -2037,8 +2037,8 @@ def WriteCmdSizeTest(self, func, file): def WriteFormatTest(self, func, file): """Writes a format test for a command.""" - file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) - file.Write(" %s cmd = { { 0 } };\n" % func.name) + file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name)) file.Write(" void* next_cmd = cmd.Set(\n") file.Write(" &cmd") args = func.GetCmdArgs() @@ -2051,41 +2051,18 @@ def WriteFormatTest(self, func, file): file.Write(" EXPECT_EQ(static_cast(%s::kCmdId),\n" % func.name) file.Write(" cmd.header.command);\n") func.type_handler.WriteCmdSizeTest(func, file) - file.Write(" EXPECT_EQ(static_cast(next_cmd),\n") - file.Write(" reinterpret_cast(&cmd) + sizeof(cmd));\n"); for arg in args: file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % (arg.type, value, arg.name)) value += 1 + file.Write(" CheckBytesWrittenMatchesExpectedSize(\n") + file.Write(" next_cmd, sizeof(cmd));\n") file.Write("}\n") file.Write("\n") def WriteImmediateFormatTest(self, func, file): """Writes a format test for an immediate version of a command.""" - file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) - file.Write(" int8 buf[256] = { 0, };\n") - file.Write(" %s& cmd = *static_cast<%s*>(static_cast(&buf));\n" % - (func.name, func.name)) - file.Write(" void* next_cmd = cmd.Set(\n") - file.Write(" &cmd") - args = func.GetCmdArgs() - value = 11 - for arg in args: - file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) - value += 1 - file.Write(");\n") - value = 11 - file.Write(" EXPECT_EQ(static_cast(%s::kCmdId),\n" % func.name) - file.Write(" cmd.header.command);\n") - func.type_handler.WriteImmediateCmdSizeTest(func, file) - file.Write(" EXPECT_EQ(static_cast(next_cmd),\n") - file.Write(" reinterpret_cast(&cmd) + sizeof(cmd));\n"); - for arg in args: - file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % - (arg.type, value, arg.name)) - value += 1 - file.Write("}\n") - file.Write("\n") + pass def WriteBucketFormatTest(self, func, file): """Writes a format test for a bucket version of a command.""" @@ -2963,33 +2940,20 @@ def WriteImmediateCmdHelper(self, func, file): def WriteImmediateFormatTest(self, func, file): """Overrriden from TypeHandler.""" - file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name) file.Write(" static GLuint ids[] = { 12, 23, 34, };\n") - file.Write(" int8 buf[256] = { 0, };\n") - file.Write(" %s& cmd = *static_cast<%s*>(static_cast(&buf));\n" % - (func.name, func.name)) + file.Write(" %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name)) file.Write(" void* next_cmd = cmd.Set(\n") - file.Write(" &cmd") - args = func.GetCmdArgs() - value = 11 - for arg in args: - file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) - value += 1 - file.Write(",\n ids);\n") - args = func.GetCmdArgs() - value = 11 + file.Write(" &cmd, static_cast(arraysize(ids)), ids);\n") file.Write(" EXPECT_EQ(static_cast(%s::kCmdId),\n" % func.name) file.Write(" cmd.header.command);\n") file.Write(" EXPECT_EQ(sizeof(cmd) +\n") file.Write(" RoundSizeToMultipleOfEntries(cmd.n * 4u),\n") file.Write(" cmd.header.size * 4u);\n") - file.Write(" EXPECT_EQ(static_cast(next_cmd),\n") - file.Write(" reinterpret_cast(&cmd) + sizeof(cmd) +\n"); - file.Write(" RoundSizeToMultipleOfEntries(cmd.n * 4u));\n"); - for arg in args: - file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % - (arg.type, value, arg.name)) - value += 1 + file.Write(" EXPECT_EQ(static_cast(arraysize(ids)), cmd.n);\n"); + file.Write(" CheckBytesWrittenMatchesExpectedSize(\n") + file.Write(" next_cmd, sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));\n") file.Write(" // TODO(gman): Check that ids were inserted;\n") file.Write("}\n") file.Write("\n") @@ -3287,33 +3251,20 @@ def WriteImmediateCmdHelper(self, func, file): def WriteImmediateFormatTest(self, func, file): """Overrriden from TypeHandler.""" - file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name) file.Write(" static GLuint ids[] = { 12, 23, 34, };\n") - file.Write(" int8 buf[256] = { 0, };\n") - file.Write(" %s& cmd = *static_cast<%s*>(static_cast(&buf));\n" % - (func.name, func.name)) + file.Write(" %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name)) file.Write(" void* next_cmd = cmd.Set(\n") - file.Write(" &cmd") - args = func.GetCmdArgs() - value = 11 - for arg in args: - file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) - value += 1 - file.Write(",\n ids);\n") - args = func.GetCmdArgs() - value = 11 + file.Write(" &cmd, static_cast(arraysize(ids)), ids);\n") file.Write(" EXPECT_EQ(static_cast(%s::kCmdId),\n" % func.name) file.Write(" cmd.header.command);\n") file.Write(" EXPECT_EQ(sizeof(cmd) +\n") file.Write(" RoundSizeToMultipleOfEntries(cmd.n * 4u),\n") file.Write(" cmd.header.size * 4u);\n") - file.Write(" EXPECT_EQ(static_cast(next_cmd),\n") - file.Write(" reinterpret_cast(&cmd) + sizeof(cmd) +\n"); - file.Write(" RoundSizeToMultipleOfEntries(cmd.n * 4u));\n"); - for arg in args: - file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % - (arg.type, value, arg.name)) - value += 1 + file.Write(" EXPECT_EQ(static_cast(arraysize(ids)), cmd.n);\n"); + file.Write(" CheckBytesWrittenMatchesExpectedSize(\n") + file.Write(" next_cmd, sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));\n") file.Write(" // TODO(gman): Check that ids were inserted;\n") file.Write("}\n") file.Write("\n") @@ -3651,16 +3602,14 @@ def WriteImmediateCmdHelper(self, func, file): def WriteImmediateFormatTest(self, func, file): """Overrriden from TypeHandler.""" - file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name) file.Write(" const int kSomeBaseValueToTestWith = 51;\n") file.Write(" static %s data[] = {\n" % func.info.data_type) for v in range(0, func.info.count): file.Write(" static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" % (func.info.data_type, v)) file.Write(" };\n") - file.Write(" int8 buf[256] = { 0, };\n") - file.Write(" %s& cmd = *static_cast<%s*>(static_cast(&buf));\n" % - (func.name, func.name)) + file.Write(" %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name)) file.Write(" void* next_cmd = cmd.Set(\n") file.Write(" &cmd") args = func.GetCmdArgs() @@ -3676,13 +3625,13 @@ def WriteImmediateFormatTest(self, func, file): file.Write(" EXPECT_EQ(sizeof(cmd) +\n") file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)),\n") file.Write(" cmd.header.size * 4u);\n") - file.Write(" EXPECT_EQ(static_cast(next_cmd),\n") - file.Write(" reinterpret_cast(&cmd) + sizeof(cmd) +\n") - file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)));\n") for arg in args: file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % (arg.type, value, arg.name)) value += 1 + file.Write(" CheckBytesWrittenMatchesExpectedSize(\n") + file.Write(" next_cmd, sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)));\n") file.Write(" // TODO(gman): Check that data was inserted;\n") file.Write("}\n") file.Write("\n") @@ -3882,16 +3831,18 @@ def WriteImmediateCmdHelper(self, func, file): def WriteImmediateFormatTest(self, func, file): """Overrriden from TypeHandler.""" - file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name) file.Write(" const int kSomeBaseValueToTestWith = 51;\n") file.Write(" static %s data[] = {\n" % func.info.data_type) for v in range(0, func.info.count * 2): file.Write(" static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" % (func.info.data_type, v)) file.Write(" };\n") - file.Write(" int8 buf[256] = { 0, };\n") - file.Write(" %s& cmd = *static_cast<%s*>(static_cast(&buf));\n" % - (func.name, func.name)) + file.Write(" %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name)) + file.Write(" const GLsizei kNumElements = 2;\n") + file.Write(" const size_t kExpectedCmdSize =\n") + file.Write(" sizeof(cmd) + kNumElements * sizeof(%s) * %d;\n" % + (func.info.data_type, func.info.count)) file.Write(" void* next_cmd = cmd.Set(\n") file.Write(" &cmd") args = func.GetCmdArgs() @@ -3904,16 +3855,14 @@ def WriteImmediateFormatTest(self, func, file): value = 1 file.Write(" EXPECT_EQ(static_cast(%s::kCmdId),\n" % func.name) file.Write(" cmd.header.command);\n") - file.Write(" EXPECT_EQ(sizeof(cmd) +\n") - file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)),\n") - file.Write(" cmd.header.size * 4u);\n") - file.Write(" EXPECT_EQ(static_cast(next_cmd),\n") - file.Write(" reinterpret_cast(&cmd) + sizeof(cmd) +\n") - file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)));\n") + file.Write(" EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);\n") for arg in args: file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % (arg.type, value, arg.name)) value += 1 + file.Write(" CheckBytesWrittenMatchesExpectedSize(\n") + file.Write(" next_cmd, sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)));\n") file.Write(" // TODO(gman): Check that data was inserted;\n") file.Write("}\n") file.Write("\n") @@ -4059,9 +4008,8 @@ def WriteImmediateFormatTest(self, func, file): (arg.type, value, arg.name)) value += 1 code = """ -TEST(GLES2FormatTest, %(func_name)s) { - int8 buf[256] = { 0, }; - %(func_name)s& cmd = *static_cast<%(func_name)s*>(static_cast(&buf)); +TEST_F(GLES2FormatTest, %(func_name)s) { + %(func_name)s& cmd = *GetBufferAs<%(func_name)s>(); static const char* const test_str = \"test string\"; void* next_cmd = cmd.Set( &cmd, @@ -4079,6 +4027,10 @@ def WriteImmediateFormatTest(self, func, file): %(check_code)s EXPECT_EQ(static_cast(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)); } """ diff --git a/gpu/command_buffer/common/gles2_cmd_format_test.cc b/gpu/command_buffer/common/gles2_cmd_format_test.cc index 78817a5cd2b6c2..396ccb3e2d7648 100644 --- a/gpu/command_buffer/common/gles2_cmd_format_test.cc +++ b/gpu/command_buffer/common/gles2_cmd_format_test.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,6 +10,47 @@ namespace gpu { namespace gles2 { +class GLES2FormatTest : public testing::Test { + protected: + static const unsigned char kInitialValue = 0xBD; + + virtual void SetUp() { + memset(buffer_, kInitialValue, sizeof(buffer_)); + } + + virtual void TearDown() { + } + + template + T* GetBufferAs() { + return static_cast(static_cast(&buffer_)); + } + + void CheckBytesWritten( + const void* end, size_t expected_size, size_t written_size) { + size_t actual_size = static_cast(end) - + GetBufferAs(); + EXPECT_LT(actual_size, sizeof(buffer_)); + EXPECT_GT(actual_size, 0u); + EXPECT_EQ(expected_size, actual_size); + EXPECT_EQ(kInitialValue, buffer_[written_size]); + EXPECT_NE(kInitialValue, buffer_[written_size - 1]); + } + + void CheckBytesWrittenMatchesExpectedSize( + const void* end, size_t expected_size) { + CheckBytesWritten(end, expected_size, expected_size); + } + + private: + unsigned char buffer_[1024]; +}; + +// GCC requires these declarations, but MSVC requires they not be present +#ifndef _MSC_VER +const unsigned char GLES2FormatTest::kInitialValue; +#endif + #include "gpu/command_buffer/common/gles2_cmd_format_test_autogen.h" } // namespace gles2 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 e10a7fed9f8ae5..d546044736bcfe 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(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(ActiveTexture::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.texture); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, AttachShader) { - AttachShader cmd = { { 0 } }; +TEST_F(GLES2FormatTest, AttachShader) { + AttachShader& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -34,14 +34,14 @@ TEST(GLES2FormatTest, AttachShader) { EXPECT_EQ(static_cast(AttachShader::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.shader); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BindAttribLocation) { - BindAttribLocation cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BindAttribLocation) { + BindAttribLocation& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -52,20 +52,19 @@ TEST(GLES2FormatTest, BindAttribLocation) { EXPECT_EQ(static_cast(BindAttribLocation::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.index); EXPECT_EQ(static_cast(13), cmd.name_shm_id); EXPECT_EQ(static_cast(14), cmd.name_shm_offset); EXPECT_EQ(static_cast(15), cmd.data_size); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BindAttribLocationImmediate) { - int8 buf[256] = { 0, }; +TEST_F(GLES2FormatTest, BindAttribLocationImmediate) { BindAttribLocationImmediate& cmd = - *static_cast(static_cast(&buf)); + *GetBufferAs(); 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(12), cmd.index); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -97,15 +100,15 @@ TEST(GLES2FormatTest, BindAttribLocationBucket) { EXPECT_EQ(static_cast(BindAttribLocationBucket::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.index); EXPECT_EQ(static_cast(13), cmd.name_bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BindBuffer) { - BindBuffer cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BindBuffer) { + BindBuffer& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -113,14 +116,14 @@ TEST(GLES2FormatTest, BindBuffer) { EXPECT_EQ(static_cast(BindBuffer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.buffer); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BindFramebuffer) { - BindFramebuffer cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BindFramebuffer) { + BindFramebuffer& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -128,14 +131,14 @@ TEST(GLES2FormatTest, BindFramebuffer) { EXPECT_EQ(static_cast(BindFramebuffer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.framebuffer); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BindRenderbuffer) { - BindRenderbuffer cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BindRenderbuffer) { + BindRenderbuffer& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -143,14 +146,14 @@ TEST(GLES2FormatTest, BindRenderbuffer) { EXPECT_EQ(static_cast(BindRenderbuffer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.renderbuffer); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BindTexture) { - BindTexture cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BindTexture) { + BindTexture& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -158,14 +161,14 @@ TEST(GLES2FormatTest, BindTexture) { EXPECT_EQ(static_cast(BindTexture::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.texture); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BlendColor) { - BlendColor cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BlendColor) { + BlendColor& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -175,29 +178,29 @@ TEST(GLES2FormatTest, BlendColor) { EXPECT_EQ(static_cast(BlendColor::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.red); EXPECT_EQ(static_cast(12), cmd.green); EXPECT_EQ(static_cast(13), cmd.blue); EXPECT_EQ(static_cast(14), cmd.alpha); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BlendEquation) { - BlendEquation cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BlendEquation) { + BlendEquation& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(BlendEquation::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.mode); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BlendEquationSeparate) { - BlendEquationSeparate cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BlendEquationSeparate) { + BlendEquationSeparate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -205,14 +208,14 @@ TEST(GLES2FormatTest, BlendEquationSeparate) { EXPECT_EQ(static_cast(BlendEquationSeparate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.modeRGB); EXPECT_EQ(static_cast(12), cmd.modeAlpha); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BlendFunc) { - BlendFunc cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BlendFunc) { + BlendFunc& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -220,14 +223,14 @@ TEST(GLES2FormatTest, BlendFunc) { EXPECT_EQ(static_cast(BlendFunc::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.sfactor); EXPECT_EQ(static_cast(12), cmd.dfactor); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BlendFuncSeparate) { - BlendFuncSeparate cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BlendFuncSeparate) { + BlendFuncSeparate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -237,16 +240,16 @@ TEST(GLES2FormatTest, BlendFuncSeparate) { EXPECT_EQ(static_cast(BlendFuncSeparate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.srcRGB); EXPECT_EQ(static_cast(12), cmd.dstRGB); EXPECT_EQ(static_cast(13), cmd.srcAlpha); EXPECT_EQ(static_cast(14), cmd.dstAlpha); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BufferData) { - BufferData cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BufferData) { + BufferData& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -257,18 +260,18 @@ TEST(GLES2FormatTest, BufferData) { EXPECT_EQ(static_cast(BufferData::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.size); EXPECT_EQ(static_cast(13), cmd.data_shm_id); EXPECT_EQ(static_cast(14), cmd.data_shm_offset); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -279,18 +282,18 @@ TEST(GLES2FormatTest, BufferSubData) { EXPECT_EQ(static_cast(BufferSubData::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.offset); EXPECT_EQ(static_cast(13), cmd.size); EXPECT_EQ(static_cast(14), cmd.data_shm_id); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -299,28 +302,28 @@ TEST(GLES2FormatTest, CheckFramebufferStatus) { EXPECT_EQ(static_cast(CheckFramebufferStatus::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Clear) { - Clear cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Clear) { + Clear& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(Clear::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.mask); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ClearColor) { - ClearColor cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ClearColor) { + ClearColor& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -330,42 +333,42 @@ TEST(GLES2FormatTest, ClearColor) { EXPECT_EQ(static_cast(ClearColor::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.red); EXPECT_EQ(static_cast(12), cmd.green); EXPECT_EQ(static_cast(13), cmd.blue); EXPECT_EQ(static_cast(14), cmd.alpha); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ClearDepthf) { - ClearDepthf cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ClearDepthf) { + ClearDepthf& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(ClearDepthf::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.depth); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ClearStencil) { - ClearStencil cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ClearStencil) { + ClearStencil& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(ClearStencil::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.s); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ColorMask) { - ColorMask cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ColorMask) { + ColorMask& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -375,29 +378,29 @@ TEST(GLES2FormatTest, ColorMask) { EXPECT_EQ(static_cast(ColorMask::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.red); EXPECT_EQ(static_cast(12), cmd.green); EXPECT_EQ(static_cast(13), cmd.blue); EXPECT_EQ(static_cast(14), cmd.alpha); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CompileShader) { - CompileShader cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CompileShader) { + CompileShader& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(CompileShader::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CompressedTexImage2D) { - CompressedTexImage2D cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CompressedTexImage2D) { + CompressedTexImage2D& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -412,8 +415,6 @@ TEST(GLES2FormatTest, CompressedTexImage2D) { EXPECT_EQ(static_cast(CompressedTexImage2D::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.internalformat); @@ -423,11 +424,13 @@ TEST(GLES2FormatTest, CompressedTexImage2D) { EXPECT_EQ(static_cast(17), cmd.imageSize); EXPECT_EQ(static_cast(18), cmd.data_shm_id); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -440,8 +443,6 @@ TEST(GLES2FormatTest, CompressedTexImage2DBucket) { EXPECT_EQ(static_cast(CompressedTexImage2DBucket::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.internalformat); @@ -449,10 +450,12 @@ TEST(GLES2FormatTest, CompressedTexImage2DBucket) { EXPECT_EQ(static_cast(15), cmd.height); EXPECT_EQ(static_cast(16), cmd.border); EXPECT_EQ(static_cast(17), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CompressedTexSubImage2D) { - CompressedTexSubImage2D cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CompressedTexSubImage2D) { + CompressedTexSubImage2D& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -468,8 +471,6 @@ TEST(GLES2FormatTest, CompressedTexSubImage2D) { EXPECT_EQ(static_cast(CompressedTexSubImage2D::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.xoffset); @@ -480,11 +481,14 @@ TEST(GLES2FormatTest, CompressedTexSubImage2D) { EXPECT_EQ(static_cast(18), cmd.imageSize); EXPECT_EQ(static_cast(19), cmd.data_shm_id); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -498,8 +502,6 @@ TEST(GLES2FormatTest, CompressedTexSubImage2DBucket) { EXPECT_EQ(static_cast(CompressedTexSubImage2DBucket::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.xoffset); @@ -508,10 +510,12 @@ TEST(GLES2FormatTest, CompressedTexSubImage2DBucket) { EXPECT_EQ(static_cast(16), cmd.height); EXPECT_EQ(static_cast(17), cmd.format); EXPECT_EQ(static_cast(18), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CopyTexImage2D) { - CopyTexImage2D cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CopyTexImage2D) { + CopyTexImage2D& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -525,8 +529,6 @@ TEST(GLES2FormatTest, CopyTexImage2D) { EXPECT_EQ(static_cast(CopyTexImage2D::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.internalformat); @@ -535,10 +537,12 @@ TEST(GLES2FormatTest, CopyTexImage2D) { EXPECT_EQ(static_cast(16), cmd.width); EXPECT_EQ(static_cast(17), cmd.height); EXPECT_EQ(static_cast(18), cmd.border); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CopyTexSubImage2D) { - CopyTexSubImage2D cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CopyTexSubImage2D) { + CopyTexSubImage2D& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -552,8 +556,6 @@ TEST(GLES2FormatTest, CopyTexSubImage2D) { EXPECT_EQ(static_cast(CopyTexSubImage2D::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.xoffset); @@ -562,23 +564,25 @@ TEST(GLES2FormatTest, CopyTexSubImage2D) { EXPECT_EQ(static_cast(16), cmd.y); EXPECT_EQ(static_cast(17), cmd.width); EXPECT_EQ(static_cast(18), cmd.height); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CreateProgram) { - CreateProgram cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CreateProgram) { + CreateProgram& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(CreateProgram::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.client_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CreateShader) { - CreateShader cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CreateShader) { + CreateShader& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -586,27 +590,27 @@ TEST(GLES2FormatTest, CreateShader) { EXPECT_EQ(static_cast(CreateShader::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.type); EXPECT_EQ(static_cast(12), cmd.client_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, CullFace) { - CullFace cmd = { { 0 } }; +TEST_F(GLES2FormatTest, CullFace) { + CullFace& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(CullFace::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.mode); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DeleteBuffers) { - DeleteBuffers cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DeleteBuffers) { + DeleteBuffers& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -615,36 +619,32 @@ TEST(GLES2FormatTest, DeleteBuffers) { EXPECT_EQ(static_cast(DeleteBuffers::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.buffers_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + DeleteBuffersImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(DeleteBuffersImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -653,49 +653,46 @@ TEST(GLES2FormatTest, DeleteFramebuffers) { EXPECT_EQ(static_cast(DeleteFramebuffers::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.framebuffers_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(DeleteFramebuffersImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(DeleteProgram::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DeleteRenderbuffers) { - DeleteRenderbuffers cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DeleteRenderbuffers) { + DeleteRenderbuffers& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -704,49 +701,46 @@ TEST(GLES2FormatTest, DeleteRenderbuffers) { EXPECT_EQ(static_cast(DeleteRenderbuffers::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.renderbuffers_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(DeleteRenderbuffersImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(DeleteShader::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DeleteTextures) { - DeleteTextures cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DeleteTextures) { + DeleteTextures& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -755,62 +749,58 @@ TEST(GLES2FormatTest, DeleteTextures) { EXPECT_EQ(static_cast(DeleteTextures::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.textures_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + DeleteTexturesImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(DeleteTexturesImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(DepthFunc::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.func); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DepthMask) { - DepthMask cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DepthMask) { + DepthMask& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(DepthMask::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.flag); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DepthRangef) { - DepthRangef cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DepthRangef) { + DepthRangef& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -818,14 +808,14 @@ TEST(GLES2FormatTest, DepthRangef) { EXPECT_EQ(static_cast(DepthRangef::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.zNear); EXPECT_EQ(static_cast(12), cmd.zFar); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DetachShader) { - DetachShader cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DetachShader) { + DetachShader& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -833,40 +823,40 @@ TEST(GLES2FormatTest, DetachShader) { EXPECT_EQ(static_cast(DetachShader::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.shader); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Disable) { - Disable cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Disable) { + Disable& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(Disable::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.cap); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DisableVertexAttribArray) { - DisableVertexAttribArray cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DisableVertexAttribArray) { + DisableVertexAttribArray& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(DisableVertexAttribArray::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.index); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DrawArrays) { - DrawArrays cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DrawArrays) { + DrawArrays& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -875,15 +865,15 @@ TEST(GLES2FormatTest, DrawArrays) { EXPECT_EQ(static_cast(DrawArrays::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.mode); EXPECT_EQ(static_cast(12), cmd.first); EXPECT_EQ(static_cast(13), cmd.count); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DrawElements) { - DrawElements cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DrawElements) { + DrawElements& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -893,64 +883,64 @@ TEST(GLES2FormatTest, DrawElements) { EXPECT_EQ(static_cast(DrawElements::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.mode); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.type); EXPECT_EQ(static_cast(14), cmd.index_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Enable) { - Enable cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Enable) { + Enable& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(Enable::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.cap); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, EnableVertexAttribArray) { - EnableVertexAttribArray cmd = { { 0 } }; +TEST_F(GLES2FormatTest, EnableVertexAttribArray) { + EnableVertexAttribArray& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(EnableVertexAttribArray::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.index); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Finish) { - Finish cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Finish) { + Finish& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(Finish::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Flush) { - Flush cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Flush) { + Flush& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(Flush::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, FramebufferRenderbuffer) { - FramebufferRenderbuffer cmd = { { 0 } }; +TEST_F(GLES2FormatTest, FramebufferRenderbuffer) { + FramebufferRenderbuffer& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -960,16 +950,16 @@ TEST(GLES2FormatTest, FramebufferRenderbuffer) { EXPECT_EQ(static_cast(FramebufferRenderbuffer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.attachment); EXPECT_EQ(static_cast(13), cmd.renderbuffertarget); EXPECT_EQ(static_cast(14), cmd.renderbuffer); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, FramebufferTexture2D) { - FramebufferTexture2D cmd = { { 0 } }; +TEST_F(GLES2FormatTest, FramebufferTexture2D) { + FramebufferTexture2D& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -980,30 +970,30 @@ TEST(GLES2FormatTest, FramebufferTexture2D) { EXPECT_EQ(static_cast(FramebufferTexture2D::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.attachment); EXPECT_EQ(static_cast(13), cmd.textarget); EXPECT_EQ(static_cast(14), cmd.texture); EXPECT_EQ(static_cast(15), cmd.level); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, FrontFace) { - FrontFace cmd = { { 0 } }; +TEST_F(GLES2FormatTest, FrontFace) { + FrontFace& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(FrontFace::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.mode); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GenBuffers) { - GenBuffers cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GenBuffers) { + GenBuffers& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1012,49 +1002,45 @@ TEST(GLES2FormatTest, GenBuffers) { EXPECT_EQ(static_cast(GenBuffers::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.buffers_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + GenBuffersImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(GenBuffersImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(GenerateMipmap::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GenFramebuffers) { - GenFramebuffers cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GenFramebuffers) { + GenFramebuffers& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1063,36 +1049,32 @@ TEST(GLES2FormatTest, GenFramebuffers) { EXPECT_EQ(static_cast(GenFramebuffers::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.framebuffers_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + GenFramebuffersImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(GenFramebuffersImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1101,36 +1083,32 @@ TEST(GLES2FormatTest, GenRenderbuffers) { EXPECT_EQ(static_cast(GenRenderbuffers::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.renderbuffers_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + GenRenderbuffersImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(GenRenderbuffersImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1139,36 +1117,32 @@ TEST(GLES2FormatTest, GenTextures) { EXPECT_EQ(static_cast(GenTextures::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.textures_shm_id); EXPECT_EQ(static_cast(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(static_cast(&buf)); + GenTexturesImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( - &cmd, - static_cast(11), - ids); + &cmd, static_cast(arraysize(ids)), ids); EXPECT_EQ(static_cast(GenTexturesImmediate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(cmd.n * 4u)); - EXPECT_EQ(static_cast(11), cmd.n); + EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1179,17 +1153,17 @@ TEST(GLES2FormatTest, GetActiveAttrib) { EXPECT_EQ(static_cast(GetActiveAttrib::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.index); EXPECT_EQ(static_cast(13), cmd.name_bucket_id); EXPECT_EQ(static_cast(14), cmd.result_shm_id); EXPECT_EQ(static_cast(15), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetActiveUniform) { - GetActiveUniform cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetActiveUniform) { + GetActiveUniform& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1200,17 +1174,17 @@ TEST(GLES2FormatTest, GetActiveUniform) { EXPECT_EQ(static_cast(GetActiveUniform::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.index); EXPECT_EQ(static_cast(13), cmd.name_bucket_id); EXPECT_EQ(static_cast(14), cmd.result_shm_id); EXPECT_EQ(static_cast(15), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetAttachedShaders) { - GetAttachedShaders cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetAttachedShaders) { + GetAttachedShaders& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1220,19 +1194,19 @@ TEST(GLES2FormatTest, GetAttachedShaders) { EXPECT_EQ(static_cast(GetAttachedShaders::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1241,15 +1215,15 @@ TEST(GLES2FormatTest, GetBooleanv) { EXPECT_EQ(static_cast(GetBooleanv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.pname); EXPECT_EQ(static_cast(12), cmd.params_shm_id); EXPECT_EQ(static_cast(13), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetBufferParameteriv) { - GetBufferParameteriv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetBufferParameteriv) { + GetBufferParameteriv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1259,16 +1233,16 @@ TEST(GLES2FormatTest, GetBufferParameteriv) { EXPECT_EQ(static_cast(GetBufferParameteriv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetError) { - GetError cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetError) { + GetError& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1276,14 +1250,14 @@ TEST(GLES2FormatTest, GetError) { EXPECT_EQ(static_cast(GetError::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.result_shm_id); EXPECT_EQ(static_cast(12), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetFloatv) { - GetFloatv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetFloatv) { + GetFloatv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1292,15 +1266,16 @@ TEST(GLES2FormatTest, GetFloatv) { EXPECT_EQ(static_cast(GetFloatv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.pname); EXPECT_EQ(static_cast(12), cmd.params_shm_id); EXPECT_EQ(static_cast(13), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) { - GetFramebufferAttachmentParameteriv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetFramebufferAttachmentParameteriv) { + GetFramebufferAttachmentParameteriv& cmd = + *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1311,17 +1286,17 @@ TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) { EXPECT_EQ(static_cast(GetFramebufferAttachmentParameteriv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.attachment); EXPECT_EQ(static_cast(13), cmd.pname); EXPECT_EQ(static_cast(14), cmd.params_shm_id); EXPECT_EQ(static_cast(15), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetIntegerv) { - GetIntegerv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetIntegerv) { + GetIntegerv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1330,15 +1305,15 @@ TEST(GLES2FormatTest, GetIntegerv) { EXPECT_EQ(static_cast(GetIntegerv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.pname); EXPECT_EQ(static_cast(12), cmd.params_shm_id); EXPECT_EQ(static_cast(13), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetProgramiv) { - GetProgramiv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetProgramiv) { + GetProgramiv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1348,16 +1323,16 @@ TEST(GLES2FormatTest, GetProgramiv) { EXPECT_EQ(static_cast(GetProgramiv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetProgramInfoLog) { - GetProgramInfoLog cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetProgramInfoLog) { + GetProgramInfoLog& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1365,14 +1340,14 @@ TEST(GLES2FormatTest, GetProgramInfoLog) { EXPECT_EQ(static_cast(GetProgramInfoLog::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetRenderbufferParameteriv) { - GetRenderbufferParameteriv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetRenderbufferParameteriv) { + GetRenderbufferParameteriv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1382,16 +1357,16 @@ TEST(GLES2FormatTest, GetRenderbufferParameteriv) { EXPECT_EQ(static_cast(GetRenderbufferParameteriv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetShaderiv) { - GetShaderiv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetShaderiv) { + GetShaderiv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1401,16 +1376,16 @@ TEST(GLES2FormatTest, GetShaderiv) { EXPECT_EQ(static_cast(GetShaderiv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetShaderInfoLog) { - GetShaderInfoLog cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetShaderInfoLog) { + GetShaderInfoLog& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1418,14 +1393,14 @@ TEST(GLES2FormatTest, GetShaderInfoLog) { EXPECT_EQ(static_cast(GetShaderInfoLog::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); EXPECT_EQ(static_cast(12), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetShaderPrecisionFormat) { - GetShaderPrecisionFormat cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetShaderPrecisionFormat) { + GetShaderPrecisionFormat& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1435,16 +1410,16 @@ TEST(GLES2FormatTest, GetShaderPrecisionFormat) { EXPECT_EQ(static_cast(GetShaderPrecisionFormat::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shadertype); EXPECT_EQ(static_cast(12), cmd.precisiontype); EXPECT_EQ(static_cast(13), cmd.result_shm_id); EXPECT_EQ(static_cast(14), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetShaderSource) { - GetShaderSource cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetShaderSource) { + GetShaderSource& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1452,14 +1427,14 @@ TEST(GLES2FormatTest, GetShaderSource) { EXPECT_EQ(static_cast(GetShaderSource::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); EXPECT_EQ(static_cast(12), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetString) { - GetString cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetString) { + GetString& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1467,14 +1442,14 @@ TEST(GLES2FormatTest, GetString) { EXPECT_EQ(static_cast(GetString::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.name); EXPECT_EQ(static_cast(12), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetTexParameterfv) { - GetTexParameterfv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetTexParameterfv) { + GetTexParameterfv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1484,16 +1459,16 @@ TEST(GLES2FormatTest, GetTexParameterfv) { EXPECT_EQ(static_cast(GetTexParameterfv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetTexParameteriv) { - GetTexParameteriv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetTexParameteriv) { + GetTexParameteriv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1503,16 +1478,16 @@ TEST(GLES2FormatTest, GetTexParameteriv) { EXPECT_EQ(static_cast(GetTexParameteriv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetUniformfv) { - GetUniformfv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetUniformfv) { + GetUniformfv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1522,16 +1497,16 @@ TEST(GLES2FormatTest, GetUniformfv) { EXPECT_EQ(static_cast(GetUniformfv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.location); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetUniformiv) { - GetUniformiv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetUniformiv) { + GetUniformiv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1541,19 +1516,19 @@ TEST(GLES2FormatTest, GetUniformiv) { EXPECT_EQ(static_cast(GetUniformiv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.location); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1563,16 +1538,16 @@ TEST(GLES2FormatTest, GetVertexAttribfv) { EXPECT_EQ(static_cast(GetVertexAttribfv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.index); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetVertexAttribiv) { - GetVertexAttribiv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetVertexAttribiv) { + GetVertexAttribiv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1582,16 +1557,16 @@ TEST(GLES2FormatTest, GetVertexAttribiv) { EXPECT_EQ(static_cast(GetVertexAttribiv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.index); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(14), cmd.params_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetVertexAttribPointerv) { - GetVertexAttribPointerv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetVertexAttribPointerv) { + GetVertexAttribPointerv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1601,16 +1576,16 @@ TEST(GLES2FormatTest, GetVertexAttribPointerv) { EXPECT_EQ(static_cast(GetVertexAttribPointerv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.index); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.pointer_shm_id); EXPECT_EQ(static_cast(14), cmd.pointer_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Hint) { - Hint cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Hint) { + Hint& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1618,14 +1593,14 @@ TEST(GLES2FormatTest, Hint) { EXPECT_EQ(static_cast(Hint::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.mode); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, IsBuffer) { - IsBuffer cmd = { { 0 } }; +TEST_F(GLES2FormatTest, IsBuffer) { + IsBuffer& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1634,15 +1609,15 @@ TEST(GLES2FormatTest, IsBuffer) { EXPECT_EQ(static_cast(IsBuffer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.buffer); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, IsEnabled) { - IsEnabled cmd = { { 0 } }; +TEST_F(GLES2FormatTest, IsEnabled) { + IsEnabled& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1651,15 +1626,15 @@ TEST(GLES2FormatTest, IsEnabled) { EXPECT_EQ(static_cast(IsEnabled::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.cap); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, IsFramebuffer) { - IsFramebuffer cmd = { { 0 } }; +TEST_F(GLES2FormatTest, IsFramebuffer) { + IsFramebuffer& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1668,15 +1643,15 @@ TEST(GLES2FormatTest, IsFramebuffer) { EXPECT_EQ(static_cast(IsFramebuffer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.framebuffer); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, IsProgram) { - IsProgram cmd = { { 0 } }; +TEST_F(GLES2FormatTest, IsProgram) { + IsProgram& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1685,15 +1660,15 @@ TEST(GLES2FormatTest, IsProgram) { EXPECT_EQ(static_cast(IsProgram::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, IsRenderbuffer) { - IsRenderbuffer cmd = { { 0 } }; +TEST_F(GLES2FormatTest, IsRenderbuffer) { + IsRenderbuffer& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1702,15 +1677,15 @@ TEST(GLES2FormatTest, IsRenderbuffer) { EXPECT_EQ(static_cast(IsRenderbuffer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.renderbuffer); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, IsShader) { - IsShader cmd = { { 0 } }; +TEST_F(GLES2FormatTest, IsShader) { + IsShader& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1719,15 +1694,15 @@ TEST(GLES2FormatTest, IsShader) { EXPECT_EQ(static_cast(IsShader::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, IsTexture) { - IsTexture cmd = { { 0 } }; +TEST_F(GLES2FormatTest, IsTexture) { + IsTexture& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1736,41 +1711,41 @@ TEST(GLES2FormatTest, IsTexture) { EXPECT_EQ(static_cast(IsTexture::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.texture); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, LineWidth) { - LineWidth cmd = { { 0 } }; +TEST_F(GLES2FormatTest, LineWidth) { + LineWidth& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(LineWidth::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.width); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, LinkProgram) { - LinkProgram cmd = { { 0 } }; +TEST_F(GLES2FormatTest, LinkProgram) { + LinkProgram& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(LinkProgram::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, PixelStorei) { - PixelStorei cmd = { { 0 } }; +TEST_F(GLES2FormatTest, PixelStorei) { + PixelStorei& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1778,14 +1753,14 @@ TEST(GLES2FormatTest, PixelStorei) { EXPECT_EQ(static_cast(PixelStorei::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.pname); EXPECT_EQ(static_cast(12), cmd.param); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, PolygonOffset) { - PolygonOffset cmd = { { 0 } }; +TEST_F(GLES2FormatTest, PolygonOffset) { + PolygonOffset& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1793,14 +1768,14 @@ TEST(GLES2FormatTest, PolygonOffset) { EXPECT_EQ(static_cast(PolygonOffset::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.factor); EXPECT_EQ(static_cast(12), cmd.units); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ReadPixels) { - ReadPixels cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ReadPixels) { + ReadPixels& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1816,8 +1791,6 @@ TEST(GLES2FormatTest, ReadPixels) { EXPECT_EQ(static_cast(ReadPixels::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.x); EXPECT_EQ(static_cast(12), cmd.y); EXPECT_EQ(static_cast(13), cmd.width); @@ -1828,21 +1801,23 @@ TEST(GLES2FormatTest, ReadPixels) { EXPECT_EQ(static_cast(18), cmd.pixels_shm_offset); EXPECT_EQ(static_cast(19), cmd.result_shm_id); EXPECT_EQ(static_cast(20), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ReleaseShaderCompiler) { - ReleaseShaderCompiler cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ReleaseShaderCompiler) { + ReleaseShaderCompiler& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(ReleaseShaderCompiler::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, RenderbufferStorage) { - RenderbufferStorage cmd = { { 0 } }; +TEST_F(GLES2FormatTest, RenderbufferStorage) { + RenderbufferStorage& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1852,16 +1827,16 @@ TEST(GLES2FormatTest, RenderbufferStorage) { EXPECT_EQ(static_cast(RenderbufferStorage::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.internalformat); EXPECT_EQ(static_cast(13), cmd.width); EXPECT_EQ(static_cast(14), cmd.height); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, SampleCoverage) { - SampleCoverage cmd = { { 0 } }; +TEST_F(GLES2FormatTest, SampleCoverage) { + SampleCoverage& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1869,14 +1844,14 @@ TEST(GLES2FormatTest, SampleCoverage) { EXPECT_EQ(static_cast(SampleCoverage::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.value); EXPECT_EQ(static_cast(12), cmd.invert); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Scissor) { - Scissor cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Scissor) { + Scissor& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1886,16 +1861,16 @@ TEST(GLES2FormatTest, Scissor) { EXPECT_EQ(static_cast(Scissor::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.x); EXPECT_EQ(static_cast(12), cmd.y); EXPECT_EQ(static_cast(13), cmd.width); EXPECT_EQ(static_cast(14), cmd.height); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ShaderBinary) { - ShaderBinary cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ShaderBinary) { + ShaderBinary& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1908,8 +1883,6 @@ TEST(GLES2FormatTest, ShaderBinary) { EXPECT_EQ(static_cast(ShaderBinary::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.n); EXPECT_EQ(static_cast(12), cmd.shaders_shm_id); EXPECT_EQ(static_cast(13), cmd.shaders_shm_offset); @@ -1917,10 +1890,12 @@ TEST(GLES2FormatTest, ShaderBinary) { EXPECT_EQ(static_cast(15), cmd.binary_shm_id); EXPECT_EQ(static_cast(16), cmd.binary_shm_offset); EXPECT_EQ(static_cast(17), cmd.length); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ShaderSource) { - ShaderSource cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ShaderSource) { + ShaderSource& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1930,17 +1905,17 @@ TEST(GLES2FormatTest, ShaderSource) { EXPECT_EQ(static_cast(ShaderSource::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); EXPECT_EQ(static_cast(12), cmd.data_shm_id); EXPECT_EQ(static_cast(13), cmd.data_shm_offset); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1948,14 +1923,14 @@ TEST(GLES2FormatTest, ShaderSourceBucket) { EXPECT_EQ(static_cast(ShaderSourceBucket::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.shader); EXPECT_EQ(static_cast(12), cmd.data_bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, StencilFunc) { - StencilFunc cmd = { { 0 } }; +TEST_F(GLES2FormatTest, StencilFunc) { + StencilFunc& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1964,15 +1939,15 @@ TEST(GLES2FormatTest, StencilFunc) { EXPECT_EQ(static_cast(StencilFunc::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.func); EXPECT_EQ(static_cast(12), cmd.ref); EXPECT_EQ(static_cast(13), cmd.mask); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, StencilFuncSeparate) { - StencilFuncSeparate cmd = { { 0 } }; +TEST_F(GLES2FormatTest, StencilFuncSeparate) { + StencilFuncSeparate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -1982,29 +1957,29 @@ TEST(GLES2FormatTest, StencilFuncSeparate) { EXPECT_EQ(static_cast(StencilFuncSeparate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.face); EXPECT_EQ(static_cast(12), cmd.func); EXPECT_EQ(static_cast(13), cmd.ref); EXPECT_EQ(static_cast(14), cmd.mask); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, StencilMask) { - StencilMask cmd = { { 0 } }; +TEST_F(GLES2FormatTest, StencilMask) { + StencilMask& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(StencilMask::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.mask); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, StencilMaskSeparate) { - StencilMaskSeparate cmd = { { 0 } }; +TEST_F(GLES2FormatTest, StencilMaskSeparate) { + StencilMaskSeparate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2012,14 +1987,14 @@ TEST(GLES2FormatTest, StencilMaskSeparate) { EXPECT_EQ(static_cast(StencilMaskSeparate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.face); EXPECT_EQ(static_cast(12), cmd.mask); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, StencilOp) { - StencilOp cmd = { { 0 } }; +TEST_F(GLES2FormatTest, StencilOp) { + StencilOp& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2028,15 +2003,15 @@ TEST(GLES2FormatTest, StencilOp) { EXPECT_EQ(static_cast(StencilOp::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.fail); EXPECT_EQ(static_cast(12), cmd.zfail); EXPECT_EQ(static_cast(13), cmd.zpass); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, StencilOpSeparate) { - StencilOpSeparate cmd = { { 0 } }; +TEST_F(GLES2FormatTest, StencilOpSeparate) { + StencilOpSeparate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2046,16 +2021,16 @@ TEST(GLES2FormatTest, StencilOpSeparate) { EXPECT_EQ(static_cast(StencilOpSeparate::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.face); EXPECT_EQ(static_cast(12), cmd.fail); EXPECT_EQ(static_cast(13), cmd.zfail); EXPECT_EQ(static_cast(14), cmd.zpass); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, TexImage2D) { - TexImage2D cmd = { { 0 } }; +TEST_F(GLES2FormatTest, TexImage2D) { + TexImage2D& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2071,8 +2046,6 @@ TEST(GLES2FormatTest, TexImage2D) { EXPECT_EQ(static_cast(TexImage2D::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.internalformat); @@ -2083,11 +2056,13 @@ TEST(GLES2FormatTest, TexImage2D) { EXPECT_EQ(static_cast(18), cmd.type); EXPECT_EQ(static_cast(19), cmd.pixels_shm_id); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2096,15 +2071,15 @@ TEST(GLES2FormatTest, TexParameterf) { EXPECT_EQ(static_cast(TexParameterf::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.param); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, TexParameterfv) { - TexParameterfv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, TexParameterfv) { + TexParameterfv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2114,22 +2089,20 @@ TEST(GLES2FormatTest, TexParameterfv) { EXPECT_EQ(static_cast(TexParameterfv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), }; - int8 buf[256] = { 0, }; - TexParameterfvImmediate& cmd = - *static_cast(static_cast(&buf)); + TexParameterfvImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2140,16 +2113,16 @@ TEST(GLES2FormatTest, TexParameterfvImmediate) { EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2158,15 +2131,15 @@ TEST(GLES2FormatTest, TexParameteri) { EXPECT_EQ(static_cast(TexParameteri::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.param); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, TexParameteriv) { - TexParameteriv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, TexParameteriv) { + TexParameteriv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2176,22 +2149,20 @@ TEST(GLES2FormatTest, TexParameteriv) { EXPECT_EQ(static_cast(TexParameteriv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.pname); EXPECT_EQ(static_cast(13), cmd.params_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), }; - int8 buf[256] = { 0, }; - TexParameterivImmediate& cmd = - *static_cast(static_cast(&buf)); + TexParameterivImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2202,16 +2173,16 @@ TEST(GLES2FormatTest, TexParameterivImmediate) { EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2228,8 +2199,6 @@ TEST(GLES2FormatTest, TexSubImage2D) { EXPECT_EQ(static_cast(TexSubImage2D::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.level); EXPECT_EQ(static_cast(13), cmd.xoffset); @@ -2241,11 +2210,13 @@ TEST(GLES2FormatTest, TexSubImage2D) { EXPECT_EQ(static_cast(19), cmd.pixels_shm_id); EXPECT_EQ(static_cast(20), cmd.pixels_shm_offset); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2253,14 +2224,14 @@ TEST(GLES2FormatTest, Uniform1f) { EXPECT_EQ(static_cast(Uniform1f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform1fv) { - Uniform1fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform1fv) { + Uniform1fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2270,23 +2241,24 @@ TEST(GLES2FormatTest, Uniform1fv) { EXPECT_EQ(static_cast(Uniform1fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), static_cast(kSomeBaseValueToTestWith + 1), }; - int8 buf[256] = { 0, }; - Uniform1fvImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform1fvImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLfloat) * 1; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2294,19 +2266,17 @@ TEST(GLES2FormatTest, Uniform1fvImmediate) { data); EXPECT_EQ(static_cast(Uniform1fvImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2314,14 +2284,14 @@ TEST(GLES2FormatTest, Uniform1i) { EXPECT_EQ(static_cast(Uniform1i::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform1iv) { - Uniform1iv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform1iv) { + Uniform1iv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2331,23 +2301,24 @@ TEST(GLES2FormatTest, Uniform1iv) { EXPECT_EQ(static_cast(Uniform1iv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), static_cast(kSomeBaseValueToTestWith + 1), }; - int8 buf[256] = { 0, }; - Uniform1ivImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform1ivImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLint) * 1; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2355,19 +2326,17 @@ TEST(GLES2FormatTest, Uniform1ivImmediate) { data); EXPECT_EQ(static_cast(Uniform1ivImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2376,15 +2345,15 @@ TEST(GLES2FormatTest, Uniform2f) { EXPECT_EQ(static_cast(Uniform2f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform2fv) { - Uniform2fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform2fv) { + Uniform2fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2394,15 +2363,15 @@ TEST(GLES2FormatTest, Uniform2fv) { EXPECT_EQ(static_cast(Uniform2fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2410,9 +2379,10 @@ TEST(GLES2FormatTest, Uniform2fvImmediate) { static_cast(kSomeBaseValueToTestWith + 2), static_cast(kSomeBaseValueToTestWith + 3), }; - int8 buf[256] = { 0, }; - Uniform2fvImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform2fvImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLfloat) * 2; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2420,19 +2390,17 @@ TEST(GLES2FormatTest, Uniform2fvImmediate) { data); EXPECT_EQ(static_cast(Uniform2fvImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2441,15 +2409,15 @@ TEST(GLES2FormatTest, Uniform2i) { EXPECT_EQ(static_cast(Uniform2i::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform2iv) { - Uniform2iv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform2iv) { + Uniform2iv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2459,15 +2427,15 @@ TEST(GLES2FormatTest, Uniform2iv) { EXPECT_EQ(static_cast(Uniform2iv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2475,9 +2443,10 @@ TEST(GLES2FormatTest, Uniform2ivImmediate) { static_cast(kSomeBaseValueToTestWith + 2), static_cast(kSomeBaseValueToTestWith + 3), }; - int8 buf[256] = { 0, }; - Uniform2ivImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform2ivImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLint) * 2; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2485,19 +2454,17 @@ TEST(GLES2FormatTest, Uniform2ivImmediate) { data); EXPECT_EQ(static_cast(Uniform2ivImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2507,16 +2474,16 @@ TEST(GLES2FormatTest, Uniform3f) { EXPECT_EQ(static_cast(Uniform3f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); EXPECT_EQ(static_cast(14), cmd.z); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform3fv) { - Uniform3fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform3fv) { + Uniform3fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2526,15 +2493,15 @@ TEST(GLES2FormatTest, Uniform3fv) { EXPECT_EQ(static_cast(Uniform3fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2544,9 +2511,10 @@ TEST(GLES2FormatTest, Uniform3fvImmediate) { static_cast(kSomeBaseValueToTestWith + 4), static_cast(kSomeBaseValueToTestWith + 5), }; - int8 buf[256] = { 0, }; - Uniform3fvImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform3fvImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLfloat) * 3; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2554,19 +2522,17 @@ TEST(GLES2FormatTest, Uniform3fvImmediate) { data); EXPECT_EQ(static_cast(Uniform3fvImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2576,16 +2542,16 @@ TEST(GLES2FormatTest, Uniform3i) { EXPECT_EQ(static_cast(Uniform3i::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); EXPECT_EQ(static_cast(14), cmd.z); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform3iv) { - Uniform3iv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform3iv) { + Uniform3iv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2595,15 +2561,15 @@ TEST(GLES2FormatTest, Uniform3iv) { EXPECT_EQ(static_cast(Uniform3iv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2613,9 +2579,10 @@ TEST(GLES2FormatTest, Uniform3ivImmediate) { static_cast(kSomeBaseValueToTestWith + 4), static_cast(kSomeBaseValueToTestWith + 5), }; - int8 buf[256] = { 0, }; - Uniform3ivImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform3ivImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLint) * 3; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2623,19 +2590,17 @@ TEST(GLES2FormatTest, Uniform3ivImmediate) { data); EXPECT_EQ(static_cast(Uniform3ivImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2646,17 +2611,17 @@ TEST(GLES2FormatTest, Uniform4f) { EXPECT_EQ(static_cast(Uniform4f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); EXPECT_EQ(static_cast(14), cmd.z); EXPECT_EQ(static_cast(15), cmd.w); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform4fv) { - Uniform4fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform4fv) { + Uniform4fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2666,15 +2631,15 @@ TEST(GLES2FormatTest, Uniform4fv) { EXPECT_EQ(static_cast(Uniform4fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2686,9 +2651,10 @@ TEST(GLES2FormatTest, Uniform4fvImmediate) { static_cast(kSomeBaseValueToTestWith + 6), static_cast(kSomeBaseValueToTestWith + 7), }; - int8 buf[256] = { 0, }; - Uniform4fvImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform4fvImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2696,19 +2662,17 @@ TEST(GLES2FormatTest, Uniform4fvImmediate) { data); EXPECT_EQ(static_cast(Uniform4fvImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2719,17 +2683,17 @@ TEST(GLES2FormatTest, Uniform4i) { EXPECT_EQ(static_cast(Uniform4i::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); EXPECT_EQ(static_cast(14), cmd.z); EXPECT_EQ(static_cast(15), cmd.w); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Uniform4iv) { - Uniform4iv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Uniform4iv) { + Uniform4iv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2739,15 +2703,15 @@ TEST(GLES2FormatTest, Uniform4iv) { EXPECT_EQ(static_cast(Uniform4iv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.v_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2759,9 +2723,10 @@ TEST(GLES2FormatTest, Uniform4ivImmediate) { static_cast(kSomeBaseValueToTestWith + 6), static_cast(kSomeBaseValueToTestWith + 7), }; - int8 buf[256] = { 0, }; - Uniform4ivImmediate& cmd = - *static_cast(static_cast(&buf)); + Uniform4ivImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLint) * 4; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2769,19 +2734,17 @@ TEST(GLES2FormatTest, Uniform4ivImmediate) { data); EXPECT_EQ(static_cast(Uniform4ivImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2792,16 +2755,16 @@ TEST(GLES2FormatTest, UniformMatrix2fv) { EXPECT_EQ(static_cast(UniformMatrix2fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.transpose); EXPECT_EQ(static_cast(14), cmd.value_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2813,9 +2776,10 @@ TEST(GLES2FormatTest, UniformMatrix2fvImmediate) { static_cast(kSomeBaseValueToTestWith + 6), static_cast(kSomeBaseValueToTestWith + 7), }; - int8 buf[256] = { 0, }; - UniformMatrix2fvImmediate& cmd = - *static_cast(static_cast(&buf)); + UniformMatrix2fvImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2824,20 +2788,18 @@ TEST(GLES2FormatTest, UniformMatrix2fvImmediate) { data); EXPECT_EQ(static_cast(UniformMatrix2fvImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(2), cmd.count); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2848,16 +2810,16 @@ TEST(GLES2FormatTest, UniformMatrix3fv) { EXPECT_EQ(static_cast(UniformMatrix3fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.transpose); EXPECT_EQ(static_cast(14), cmd.value_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2879,9 +2841,10 @@ TEST(GLES2FormatTest, UniformMatrix3fvImmediate) { static_cast(kSomeBaseValueToTestWith + 16), static_cast(kSomeBaseValueToTestWith + 17), }; - int8 buf[256] = { 0, }; - UniformMatrix3fvImmediate& cmd = - *static_cast(static_cast(&buf)); + UniformMatrix3fvImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLfloat) * 9; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2890,20 +2853,18 @@ TEST(GLES2FormatTest, UniformMatrix3fvImmediate) { data); EXPECT_EQ(static_cast(UniformMatrix3fvImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(2), cmd.count); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -2914,16 +2875,16 @@ TEST(GLES2FormatTest, UniformMatrix4fv) { EXPECT_EQ(static_cast(UniformMatrix4fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.location); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.transpose); EXPECT_EQ(static_cast(14), cmd.value_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -2959,9 +2920,10 @@ TEST(GLES2FormatTest, UniformMatrix4fvImmediate) { static_cast(kSomeBaseValueToTestWith + 30), static_cast(kSomeBaseValueToTestWith + 31), }; - int8 buf[256] = { 0, }; - UniformMatrix4fvImmediate& cmd = - *static_cast(static_cast(&buf)); + UniformMatrix4fvImmediate& cmd = *GetBufferAs(); + const GLsizei kNumElements = 2; + const size_t kExpectedCmdSize = + sizeof(cmd) + kNumElements * sizeof(GLfloat) * 16; void* next_cmd = cmd.Set( &cmd, static_cast(1), @@ -2970,46 +2932,44 @@ TEST(GLES2FormatTest, UniformMatrix4fvImmediate) { data); EXPECT_EQ(static_cast(UniformMatrix4fvImmediate::kCmdId), cmd.header.command); - EXPECT_EQ(sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data)), - cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); + EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u); EXPECT_EQ(static_cast(1), cmd.location); EXPECT_EQ(static_cast(2), cmd.count); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(UseProgram::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ValidateProgram) { - ValidateProgram cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ValidateProgram) { + ValidateProgram& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(ValidateProgram::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, VertexAttrib1f) { - VertexAttrib1f cmd = { { 0 } }; +TEST_F(GLES2FormatTest, VertexAttrib1f) { + VertexAttrib1f& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3017,14 +2977,14 @@ TEST(GLES2FormatTest, VertexAttrib1f) { EXPECT_EQ(static_cast(VertexAttrib1f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.x); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, VertexAttrib1fv) { - VertexAttrib1fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, VertexAttrib1fv) { + VertexAttrib1fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3033,21 +2993,19 @@ TEST(GLES2FormatTest, VertexAttrib1fv) { EXPECT_EQ(static_cast(VertexAttrib1fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.values_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), }; - int8 buf[256] = { 0, }; - VertexAttrib1fvImmediate& cmd = - *static_cast(static_cast(&buf)); + VertexAttrib1fvImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3057,15 +3015,15 @@ TEST(GLES2FormatTest, VertexAttrib1fvImmediate) { EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3074,15 +3032,15 @@ TEST(GLES2FormatTest, VertexAttrib2f) { EXPECT_EQ(static_cast(VertexAttrib2f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, VertexAttrib2fv) { - VertexAttrib2fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, VertexAttrib2fv) { + VertexAttrib2fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3091,22 +3049,20 @@ TEST(GLES2FormatTest, VertexAttrib2fv) { EXPECT_EQ(static_cast(VertexAttrib2fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.values_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), static_cast(kSomeBaseValueToTestWith + 1), }; - int8 buf[256] = { 0, }; - VertexAttrib2fvImmediate& cmd = - *static_cast(static_cast(&buf)); + VertexAttrib2fvImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3116,15 +3072,15 @@ TEST(GLES2FormatTest, VertexAttrib2fvImmediate) { EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3134,16 +3090,16 @@ TEST(GLES2FormatTest, VertexAttrib3f) { EXPECT_EQ(static_cast(VertexAttrib3f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); EXPECT_EQ(static_cast(14), cmd.z); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, VertexAttrib3fv) { - VertexAttrib3fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, VertexAttrib3fv) { + VertexAttrib3fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3152,23 +3108,21 @@ TEST(GLES2FormatTest, VertexAttrib3fv) { EXPECT_EQ(static_cast(VertexAttrib3fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.values_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), static_cast(kSomeBaseValueToTestWith + 1), static_cast(kSomeBaseValueToTestWith + 2), }; - int8 buf[256] = { 0, }; - VertexAttrib3fvImmediate& cmd = - *static_cast(static_cast(&buf)); + VertexAttrib3fvImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3178,15 +3132,15 @@ TEST(GLES2FormatTest, VertexAttrib3fvImmediate) { EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3197,17 +3151,17 @@ TEST(GLES2FormatTest, VertexAttrib4f) { EXPECT_EQ(static_cast(VertexAttrib4f::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.x); EXPECT_EQ(static_cast(13), cmd.y); EXPECT_EQ(static_cast(14), cmd.z); EXPECT_EQ(static_cast(15), cmd.w); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, VertexAttrib4fv) { - VertexAttrib4fv cmd = { { 0 } }; +TEST_F(GLES2FormatTest, VertexAttrib4fv) { + VertexAttrib4fv& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3216,14 +3170,14 @@ TEST(GLES2FormatTest, VertexAttrib4fv) { EXPECT_EQ(static_cast(VertexAttrib4fv::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.values_shm_id); EXPECT_EQ(static_cast(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(kSomeBaseValueToTestWith + 0), @@ -3231,9 +3185,7 @@ TEST(GLES2FormatTest, VertexAttrib4fvImmediate) { static_cast(kSomeBaseValueToTestWith + 2), static_cast(kSomeBaseValueToTestWith + 3), }; - int8 buf[256] = { 0, }; - VertexAttrib4fvImmediate& cmd = - *static_cast(static_cast(&buf)); + VertexAttrib4fvImmediate& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3243,15 +3195,15 @@ TEST(GLES2FormatTest, VertexAttrib4fvImmediate) { EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd) + - RoundSizeToMultipleOfEntries(sizeof(data))); EXPECT_EQ(static_cast(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(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3263,18 +3215,18 @@ TEST(GLES2FormatTest, VertexAttribPointer) { EXPECT_EQ(static_cast(VertexAttribPointer::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.indx); EXPECT_EQ(static_cast(12), cmd.size); EXPECT_EQ(static_cast(13), cmd.type); EXPECT_EQ(static_cast(14), cmd.normalized); EXPECT_EQ(static_cast(15), cmd.stride); EXPECT_EQ(static_cast(16), cmd.offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Viewport) { - Viewport cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Viewport) { + Viewport& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3284,16 +3236,16 @@ TEST(GLES2FormatTest, Viewport) { EXPECT_EQ(static_cast(Viewport::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.x); EXPECT_EQ(static_cast(12), cmd.y); EXPECT_EQ(static_cast(13), cmd.width); EXPECT_EQ(static_cast(14), cmd.height); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, BlitFramebufferEXT) { - BlitFramebufferEXT cmd = { { 0 } }; +TEST_F(GLES2FormatTest, BlitFramebufferEXT) { + BlitFramebufferEXT& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3309,8 +3261,6 @@ TEST(GLES2FormatTest, BlitFramebufferEXT) { EXPECT_EQ(static_cast(BlitFramebufferEXT::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.srcX0); EXPECT_EQ(static_cast(12), cmd.srcY0); EXPECT_EQ(static_cast(13), cmd.srcX1); @@ -3321,10 +3271,13 @@ TEST(GLES2FormatTest, BlitFramebufferEXT) { EXPECT_EQ(static_cast(18), cmd.dstY1); EXPECT_EQ(static_cast(19), cmd.mask); EXPECT_EQ(static_cast(20), cmd.filter); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, RenderbufferStorageMultisampleEXT) { - RenderbufferStorageMultisampleEXT cmd = { { 0 } }; +TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleEXT) { + RenderbufferStorageMultisampleEXT& cmd = + *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3335,28 +3288,29 @@ TEST(GLES2FormatTest, RenderbufferStorageMultisampleEXT) { EXPECT_EQ(static_cast(RenderbufferStorageMultisampleEXT::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.target); EXPECT_EQ(static_cast(12), cmd.samples); EXPECT_EQ(static_cast(13), cmd.internalformat); EXPECT_EQ(static_cast(14), cmd.width); EXPECT_EQ(static_cast(15), cmd.height); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, SwapBuffers) { - SwapBuffers cmd = { { 0 } }; +TEST_F(GLES2FormatTest, SwapBuffers) { + SwapBuffers& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(SwapBuffers::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) { - GetMaxValueInBufferCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) { + GetMaxValueInBufferCHROMIUM& cmd = + *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3368,18 +3322,18 @@ TEST(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) { EXPECT_EQ(static_cast(GetMaxValueInBufferCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.buffer_id); EXPECT_EQ(static_cast(12), cmd.count); EXPECT_EQ(static_cast(13), cmd.type); EXPECT_EQ(static_cast(14), cmd.offset); EXPECT_EQ(static_cast(15), cmd.result_shm_id); EXPECT_EQ(static_cast(16), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GenSharedIdsCHROMIUM) { - GenSharedIdsCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GenSharedIdsCHROMIUM) { + GenSharedIdsCHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3390,17 +3344,17 @@ TEST(GLES2FormatTest, GenSharedIdsCHROMIUM) { EXPECT_EQ(static_cast(GenSharedIdsCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.namespace_id); EXPECT_EQ(static_cast(12), cmd.id_offset); EXPECT_EQ(static_cast(13), cmd.n); EXPECT_EQ(static_cast(14), cmd.ids_shm_id); EXPECT_EQ(static_cast(15), cmd.ids_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, DeleteSharedIdsCHROMIUM) { - DeleteSharedIdsCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, DeleteSharedIdsCHROMIUM) { + DeleteSharedIdsCHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3410,16 +3364,16 @@ TEST(GLES2FormatTest, DeleteSharedIdsCHROMIUM) { EXPECT_EQ(static_cast(DeleteSharedIdsCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.namespace_id); EXPECT_EQ(static_cast(12), cmd.n); EXPECT_EQ(static_cast(13), cmd.ids_shm_id); EXPECT_EQ(static_cast(14), cmd.ids_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, RegisterSharedIdsCHROMIUM) { - RegisterSharedIdsCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, RegisterSharedIdsCHROMIUM) { + RegisterSharedIdsCHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3429,16 +3383,16 @@ TEST(GLES2FormatTest, RegisterSharedIdsCHROMIUM) { EXPECT_EQ(static_cast(RegisterSharedIdsCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.namespace_id); EXPECT_EQ(static_cast(12), cmd.n); EXPECT_EQ(static_cast(13), cmd.ids_shm_id); EXPECT_EQ(static_cast(14), cmd.ids_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, EnableFeatureCHROMIUM) { - EnableFeatureCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, EnableFeatureCHROMIUM) { + EnableFeatureCHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3447,15 +3401,15 @@ TEST(GLES2FormatTest, EnableFeatureCHROMIUM) { EXPECT_EQ(static_cast(EnableFeatureCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.bucket_id); EXPECT_EQ(static_cast(12), cmd.result_shm_id); EXPECT_EQ(static_cast(13), cmd.result_shm_offset); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, ResizeCHROMIUM) { - ResizeCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, ResizeCHROMIUM) { + ResizeCHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3463,40 +3417,42 @@ TEST(GLES2FormatTest, ResizeCHROMIUM) { EXPECT_EQ(static_cast(ResizeCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.width); EXPECT_EQ(static_cast(12), cmd.height); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) { - GetRequestableExtensionsCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) { + GetRequestableExtensionsCHROMIUM& cmd = + *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(GetRequestableExtensionsCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, RequestExtensionCHROMIUM) { - RequestExtensionCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, RequestExtensionCHROMIUM) { + RequestExtensionCHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11)); EXPECT_EQ(static_cast(RequestExtensionCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetMultipleIntegervCHROMIUM) { - GetMultipleIntegervCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetMultipleIntegervCHROMIUM) { + GetMultipleIntegervCHROMIUM& cmd = + *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3508,18 +3464,18 @@ TEST(GLES2FormatTest, GetMultipleIntegervCHROMIUM) { EXPECT_EQ(static_cast(GetMultipleIntegervCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.pnames_shm_id); EXPECT_EQ(static_cast(12), cmd.pnames_shm_offset); EXPECT_EQ(static_cast(13), cmd.count); EXPECT_EQ(static_cast(14), cmd.results_shm_id); EXPECT_EQ(static_cast(15), cmd.results_shm_offset); EXPECT_EQ(static_cast(16), cmd.size); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, GetProgramInfoCHROMIUM) { - GetProgramInfoCHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, GetProgramInfoCHROMIUM) { + GetProgramInfoCHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd, static_cast(11), @@ -3527,54 +3483,54 @@ TEST(GLES2FormatTest, GetProgramInfoCHROMIUM) { EXPECT_EQ(static_cast(GetProgramInfoCHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); EXPECT_EQ(static_cast(11), cmd.program); EXPECT_EQ(static_cast(12), cmd.bucket_id); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Placeholder447CHROMIUM) { - Placeholder447CHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Placeholder447CHROMIUM) { + Placeholder447CHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(Placeholder447CHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Placeholder451CHROMIUM) { - Placeholder451CHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Placeholder451CHROMIUM) { + Placeholder451CHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(Placeholder451CHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Placeholder452CHROMIUM) { - Placeholder452CHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Placeholder452CHROMIUM) { + Placeholder452CHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(Placeholder452CHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } -TEST(GLES2FormatTest, Placeholder453CHROMIUM) { - Placeholder453CHROMIUM cmd = { { 0 } }; +TEST_F(GLES2FormatTest, Placeholder453CHROMIUM) { + Placeholder453CHROMIUM& cmd = *GetBufferAs(); void* next_cmd = cmd.Set( &cmd); EXPECT_EQ(static_cast(Placeholder453CHROMIUM::kCmdId), cmd.header.command); EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u); - EXPECT_EQ(static_cast(next_cmd), - reinterpret_cast(&cmd) + sizeof(cmd)); + CheckBytesWrittenMatchesExpectedSize( + next_cmd, sizeof(cmd)); } #endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_ diff --git a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h index 559fe887939431..b74a318e8d4668 100644 --- a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h +++ b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h @@ -179,7 +179,7 @@ static GLES2Util::EnumToString enum_to_string_table[] = { { 0x00000400, "GL_STENCIL_BUFFER_BIT", }, { 0x800A, "GL_FUNC_SUBTRACT", }, { 0x8E2C, "GL_DEPTH_COMPONENT16_NONLINEAR_NV", }, - { 0x8508, "GL_DECR_WRAP", }, + { 0x889F, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", }, { 0x8006, "GL_FUNC_ADD", }, { 0x8007, "GL_MIN_EXT", }, { 0x8004, "GL_ONE_MINUS_CONSTANT_ALPHA", }, @@ -408,7 +408,7 @@ static GLES2Util::EnumToString enum_to_string_table[] = { { 0x80CA, "GL_BLEND_DST_ALPHA", }, { 0x8CD6, "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT", }, { 0x8872, "GL_MAX_TEXTURE_IMAGE_UNITS", }, - { 0x889F, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", }, + { 0x8508, "GL_DECR_WRAP", }, { 0x8507, "GL_INCR_WRAP", }, { 0x8895, "GL_ELEMENT_ARRAY_BUFFER_BINDING", }, { 0x8894, "GL_ARRAY_BUFFER_BINDING", },