| /* |
| ** Copyright 2011, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #include <sys/socket.h> |
| #include <sys/ioctl.h> |
| |
| #include "header.h" |
| #include "gtest/gtest.h" |
| #include "egl_tls.h" |
| #include "hooks.h" |
| |
| namespace android |
| { |
| extern int serverSock, clientSock; |
| extern pthread_key_t dbgEGLThreadLocalStorageKey; |
| }; |
| |
| void * glNoop(); |
| |
| class SocketContextTest : public ::testing::Test |
| { |
| protected: |
| tls_t tls; |
| gl_hooks_t hooks; |
| int sock; |
| char * buffer; |
| unsigned int bufferSize; |
| |
| SocketContextTest() : sock(-1) { |
| } |
| |
| virtual ~SocketContextTest() { |
| } |
| |
| virtual void SetUp() { |
| if (dbgEGLThreadLocalStorageKey == -1) |
| pthread_key_create(&dbgEGLThreadLocalStorageKey, NULL); |
| ASSERT_NE(-1, dbgEGLThreadLocalStorageKey); |
| tls.dbg = new DbgContext(1, &hooks, 32, GL_RGBA, GL_UNSIGNED_BYTE); |
| ASSERT_TRUE(tls.dbg != NULL); |
| pthread_setspecific(dbgEGLThreadLocalStorageKey, &tls); |
| for (unsigned int i = 0; i < sizeof(hooks) / sizeof(void *); i++) |
| ((void **)&hooks)[i] = (void *)glNoop; |
| |
| int socks[2] = {-1, -1}; |
| ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, socks)); |
| clientSock = socks[0]; |
| sock = socks[1]; |
| |
| bufferSize = 128; |
| buffer = new char [128]; |
| ASSERT_NE((char *)NULL, buffer); |
| } |
| |
| virtual void TearDown() { |
| close(sock); |
| close(clientSock); |
| clientSock = -1; |
| delete buffer; |
| } |
| |
| void Write(glesv2debugger::Message & msg) const { |
| msg.set_context_id((int)tls.dbg); |
| msg.set_type(msg.Response); |
| ASSERT_TRUE(msg.has_context_id()); |
| ASSERT_TRUE(msg.has_function()); |
| ASSERT_TRUE(msg.has_type()); |
| ASSERT_TRUE(msg.has_expect_response()); |
| static std::string str; |
| msg.SerializeToString(&str); |
| const uint32_t len = str.length(); |
| ASSERT_EQ(sizeof(len), send(sock, &len, sizeof(len), 0)); |
| ASSERT_EQ(str.length(), send(sock, str.data(), str.length(), 0)); |
| } |
| |
| void Read(glesv2debugger::Message & msg) { |
| int available = 0; |
| ASSERT_EQ(0, ioctl(sock, FIONREAD, &available)); |
| ASSERT_GT(available, 0); |
| uint32_t len = 0; |
| ASSERT_EQ(sizeof(len), recv(sock, &len, sizeof(len), 0)); |
| if (len > bufferSize) { |
| bufferSize = len; |
| buffer = new char[bufferSize]; |
| ASSERT_TRUE(buffer != NULL); |
| } |
| ASSERT_EQ(len, recv(sock, buffer, len, 0)); |
| msg.Clear(); |
| msg.ParseFromArray(buffer, len); |
| ASSERT_TRUE(msg.has_context_id()); |
| ASSERT_TRUE(msg.has_function()); |
| ASSERT_TRUE(msg.has_type()); |
| ASSERT_TRUE(msg.has_expect_response()); |
| } |
| |
| void CheckNoAvailable() { |
| int available = 0; |
| ASSERT_EQ(0, ioctl(sock, FIONREAD, &available)); |
| ASSERT_EQ(available, 0); |
| } |
| }; |
| |
| TEST_F(SocketContextTest, MessageLoopSkip) |
| { |
| static const int arg0 = 45; |
| static const float arg7 = -87.2331f; |
| static const int arg8 = -3; |
| static const int * ret = (int *)870; |
| |
| struct Caller : public FunctionCall { |
| const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { |
| msg.set_arg0(arg0); |
| msg.set_arg7((int &)arg7); |
| msg.set_arg8(arg8); |
| return ret; |
| } |
| } caller; |
| glesv2debugger::Message msg, read, cmd; |
| tls.dbg->expectResponse.Bit(msg.glFinish, true); |
| |
| cmd.set_function(cmd.SKIP); |
| cmd.set_expect_response(false); |
| Write(cmd); |
| |
| EXPECT_NE(ret, MessageLoop(caller, msg, msg.glFinish)); |
| |
| Read(read); |
| EXPECT_EQ(read.glFinish, read.function()); |
| EXPECT_EQ(read.BeforeCall, read.type()); |
| EXPECT_NE(arg0, read.arg0()); |
| EXPECT_NE((int &)arg7, read.arg7()); |
| EXPECT_NE(arg8, read.arg8()); |
| |
| CheckNoAvailable(); |
| } |
| |
| TEST_F(SocketContextTest, MessageLoopContinue) |
| { |
| static const int arg0 = GL_FRAGMENT_SHADER; |
| static const int ret = -342; |
| struct Caller : public FunctionCall { |
| const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { |
| msg.set_ret(ret); |
| return (int *)ret; |
| } |
| } caller; |
| glesv2debugger::Message msg, read, cmd; |
| tls.dbg->expectResponse.Bit(msg.glCreateShader, true); |
| |
| cmd.set_function(cmd.CONTINUE); |
| cmd.set_expect_response(false); // MessageLoop should automatically skip after continue |
| Write(cmd); |
| |
| msg.set_arg0(arg0); |
| EXPECT_EQ((int *)ret, MessageLoop(caller, msg, msg.glCreateShader)); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateShader, read.function()); |
| EXPECT_EQ(read.BeforeCall, read.type()); |
| EXPECT_EQ(arg0, read.arg0()); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateShader, read.function()); |
| EXPECT_EQ(read.AfterCall, read.type()); |
| EXPECT_EQ(ret, read.ret()); |
| |
| CheckNoAvailable(); |
| } |
| |
| TEST_F(SocketContextTest, MessageLoopGenerateCall) |
| { |
| static const int ret = -342; |
| static unsigned int createShader, createProgram; |
| createShader = 0; |
| createProgram = 0; |
| struct Caller : public FunctionCall { |
| const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { |
| const int r = (int)_c->glCreateProgram(); |
| msg.set_ret(r); |
| return (int *)r; |
| } |
| static GLuint CreateShader(const GLenum type) { |
| createShader++; |
| return type; |
| } |
| static GLuint CreateProgram() { |
| createProgram++; |
| return ret; |
| } |
| } caller; |
| glesv2debugger::Message msg, read, cmd; |
| hooks.gl.glCreateShader = caller.CreateShader; |
| hooks.gl.glCreateProgram = caller.CreateProgram; |
| tls.dbg->expectResponse.Bit(msg.glCreateProgram, true); |
| |
| cmd.set_function(cmd.glCreateShader); |
| cmd.set_arg0(GL_FRAGMENT_SHADER); |
| cmd.set_expect_response(true); |
| Write(cmd); |
| |
| cmd.Clear(); |
| cmd.set_function(cmd.CONTINUE); |
| cmd.set_expect_response(true); |
| Write(cmd); |
| |
| cmd.set_function(cmd.glCreateShader); |
| cmd.set_arg0(GL_VERTEX_SHADER); |
| cmd.set_expect_response(false); // MessageLoop should automatically skip afterwards |
| Write(cmd); |
| |
| EXPECT_EQ((int *)ret, MessageLoop(caller, msg, msg.glCreateProgram)); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateProgram, read.function()); |
| EXPECT_EQ(read.BeforeCall, read.type()); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateShader, read.function()); |
| EXPECT_EQ(read.AfterGeneratedCall, read.type()); |
| EXPECT_EQ(GL_FRAGMENT_SHADER, read.ret()); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateProgram, read.function()); |
| EXPECT_EQ(read.AfterCall, read.type()); |
| EXPECT_EQ(ret, read.ret()); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateShader, read.function()); |
| EXPECT_EQ(read.AfterGeneratedCall, read.type()); |
| EXPECT_EQ(GL_VERTEX_SHADER, read.ret()); |
| |
| EXPECT_EQ(2, createShader); |
| EXPECT_EQ(1, createProgram); |
| |
| CheckNoAvailable(); |
| } |
| |
| TEST_F(SocketContextTest, MessageLoopSetProp) |
| { |
| static const int ret = -342; |
| static unsigned int createShader, createProgram; |
| createShader = 0; |
| createProgram = 0; |
| struct Caller : public FunctionCall { |
| const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) { |
| const int r = (int)_c->glCreateProgram(); |
| msg.set_ret(r); |
| return (int *)r; |
| } |
| static GLuint CreateShader(const GLenum type) { |
| createShader++; |
| return type; |
| } |
| static GLuint CreateProgram() { |
| createProgram++; |
| return ret; |
| } |
| } caller; |
| glesv2debugger::Message msg, read, cmd; |
| hooks.gl.glCreateShader = caller.CreateShader; |
| hooks.gl.glCreateProgram = caller.CreateProgram; |
| tls.dbg->expectResponse.Bit(msg.glCreateProgram, false); |
| |
| cmd.set_function(cmd.SETPROP); |
| cmd.set_prop(cmd.ExpectResponse); |
| cmd.set_arg0(cmd.glCreateProgram); |
| cmd.set_arg1(true); |
| cmd.set_expect_response(true); |
| Write(cmd); |
| |
| cmd.Clear(); |
| cmd.set_function(cmd.glCreateShader); |
| cmd.set_arg0(GL_FRAGMENT_SHADER); |
| cmd.set_expect_response(true); |
| Write(cmd); |
| |
| cmd.set_function(cmd.SETPROP); |
| cmd.set_prop(cmd.CaptureDraw); |
| cmd.set_arg0(819); |
| cmd.set_expect_response(true); |
| Write(cmd); |
| |
| cmd.Clear(); |
| cmd.set_function(cmd.CONTINUE); |
| cmd.set_expect_response(true); |
| Write(cmd); |
| |
| cmd.set_function(cmd.glCreateShader); |
| cmd.set_arg0(GL_VERTEX_SHADER); |
| cmd.set_expect_response(false); // MessageLoop should automatically skip afterwards |
| Write(cmd); |
| |
| EXPECT_EQ((int *)ret, MessageLoop(caller, msg, msg.glCreateProgram)); |
| |
| EXPECT_TRUE(tls.dbg->expectResponse.Bit(msg.glCreateProgram)); |
| EXPECT_EQ(819, tls.dbg->captureDraw); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateProgram, read.function()); |
| EXPECT_EQ(read.BeforeCall, read.type()); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateShader, read.function()); |
| EXPECT_EQ(read.AfterGeneratedCall, read.type()); |
| EXPECT_EQ(GL_FRAGMENT_SHADER, read.ret()); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateProgram, read.function()); |
| EXPECT_EQ(read.AfterCall, read.type()); |
| EXPECT_EQ(ret, read.ret()); |
| |
| Read(read); |
| EXPECT_EQ(read.glCreateShader, read.function()); |
| EXPECT_EQ(read.AfterGeneratedCall, read.type()); |
| EXPECT_EQ(GL_VERTEX_SHADER, read.ret()); |
| |
| EXPECT_EQ(2, createShader); |
| EXPECT_EQ(1, createProgram); |
| |
| CheckNoAvailable(); |
| } |
| |
| TEST_F(SocketContextTest, TexImage2D) |
| { |
| static const GLenum _target = GL_TEXTURE_2D; |
| static const GLint _level = 1, _internalformat = GL_RGBA; |
| static const GLsizei _width = 2, _height = 2; |
| static const GLint _border = 333; |
| static const GLenum _format = GL_RGB, _type = GL_UNSIGNED_SHORT_5_6_5; |
| static const short _pixels [_width * _height] = {11, 22, 33, 44}; |
| static unsigned int texImage2D; |
| texImage2D = 0; |
| |
| struct Caller { |
| static void TexImage2D(GLenum target, GLint level, GLint internalformat, |
| GLsizei width, GLsizei height, GLint border, |
| GLenum format, GLenum type, const GLvoid* pixels) { |
| EXPECT_EQ(_target, target); |
| EXPECT_EQ(_level, level); |
| EXPECT_EQ(_internalformat, internalformat); |
| EXPECT_EQ(_width, width); |
| EXPECT_EQ(_height, height); |
| EXPECT_EQ(_border, border); |
| EXPECT_EQ(_format, format); |
| EXPECT_EQ(_type, type); |
| EXPECT_EQ(0, memcmp(_pixels, pixels, sizeof(_pixels))); |
| texImage2D++; |
| } |
| } caller; |
| glesv2debugger::Message msg, read, cmd; |
| hooks.gl.glTexImage2D = caller.TexImage2D; |
| tls.dbg->expectResponse.Bit(msg.glTexImage2D, false); |
| |
| Debug_glTexImage2D(_target, _level, _internalformat, _width, _height, _border, |
| _format, _type, _pixels); |
| EXPECT_EQ(1, texImage2D); |
| |
| Read(read); |
| EXPECT_EQ(read.glTexImage2D, read.function()); |
| EXPECT_EQ(read.BeforeCall, read.type()); |
| EXPECT_EQ(_target, read.arg0()); |
| EXPECT_EQ(_level, read.arg1()); |
| EXPECT_EQ(_internalformat, read.arg2()); |
| EXPECT_EQ(_width, read.arg3()); |
| EXPECT_EQ(_height, read.arg4()); |
| EXPECT_EQ(_border, read.arg5()); |
| EXPECT_EQ(_format, read.arg6()); |
| EXPECT_EQ(_type, read.arg7()); |
| |
| EXPECT_TRUE(read.has_data()); |
| uint32_t dataLen = 0; |
| const unsigned char * data = tls.dbg->Decompress(read.data().data(), |
| read.data().length(), &dataLen); |
| EXPECT_EQ(sizeof(_pixels), dataLen); |
| if (sizeof(_pixels) == dataLen) |
| EXPECT_EQ(0, memcmp(_pixels, data, sizeof(_pixels))); |
| |
| Read(read); |
| EXPECT_EQ(read.glTexImage2D, read.function()); |
| EXPECT_EQ(read.AfterCall, read.type()); |
| |
| CheckNoAvailable(); |
| } |
| |
| TEST_F(SocketContextTest, CopyTexImage2D) |
| { |
| static const GLenum _target = GL_TEXTURE_2D; |
| static const GLint _level = 1, _internalformat = GL_RGBA; |
| static const GLint _x = 9, _y = 99; |
| static const GLsizei _width = 2, _height = 3; |
| static const GLint _border = 333; |
| static const int _pixels [_width * _height] = {11, 22, 33, 44, 55, 66}; |
| static unsigned int copyTexImage2D, readPixels; |
| copyTexImage2D = 0, readPixels = 0; |
| |
| struct Caller { |
| static void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, |
| GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { |
| EXPECT_EQ(_target, target); |
| EXPECT_EQ(_level, level); |
| EXPECT_EQ(_internalformat, internalformat); |
| EXPECT_EQ(_x, x); |
| EXPECT_EQ(_y, y); |
| EXPECT_EQ(_width, width); |
| EXPECT_EQ(_height, height); |
| EXPECT_EQ(_border, border); |
| copyTexImage2D++; |
| } |
| static void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, |
| GLenum format, GLenum type, GLvoid* pixels) { |
| EXPECT_EQ(_x, x); |
| EXPECT_EQ(_y, y); |
| EXPECT_EQ(_width, width); |
| EXPECT_EQ(_height, height); |
| EXPECT_EQ(GL_RGBA, format); |
| EXPECT_EQ(GL_UNSIGNED_BYTE, type); |
| ASSERT_TRUE(pixels != NULL); |
| memcpy(pixels, _pixels, sizeof(_pixels)); |
| readPixels++; |
| } |
| } caller; |
| glesv2debugger::Message msg, read, cmd; |
| hooks.gl.glCopyTexImage2D = caller.CopyTexImage2D; |
| hooks.gl.glReadPixels = caller.ReadPixels; |
| tls.dbg->expectResponse.Bit(msg.glCopyTexImage2D, false); |
| |
| Debug_glCopyTexImage2D(_target, _level, _internalformat, _x, _y, _width, _height, |
| _border); |
| ASSERT_EQ(1, copyTexImage2D); |
| ASSERT_EQ(1, readPixels); |
| |
| Read(read); |
| EXPECT_EQ(read.glCopyTexImage2D, read.function()); |
| EXPECT_EQ(read.BeforeCall, read.type()); |
| EXPECT_EQ(_target, read.arg0()); |
| EXPECT_EQ(_level, read.arg1()); |
| EXPECT_EQ(_internalformat, read.arg2()); |
| EXPECT_EQ(_x, read.arg3()); |
| EXPECT_EQ(_y, read.arg4()); |
| EXPECT_EQ(_width, read.arg5()); |
| EXPECT_EQ(_height, read.arg6()); |
| EXPECT_EQ(_border, read.arg7()); |
| |
| EXPECT_TRUE(read.has_data()); |
| EXPECT_EQ(read.ReferencedImage, read.data_type()); |
| EXPECT_EQ(GL_RGBA, read.pixel_format()); |
| EXPECT_EQ(GL_UNSIGNED_BYTE, read.pixel_type()); |
| uint32_t dataLen = 0; |
| unsigned char * const data = tls.dbg->Decompress(read.data().data(), |
| read.data().length(), &dataLen); |
| ASSERT_EQ(sizeof(_pixels), dataLen); |
| for (unsigned i = 0; i < sizeof(_pixels) / sizeof(*_pixels); i++) |
| EXPECT_EQ(_pixels[i], ((const int *)data)[i]) << "xor with 0 ref is identity"; |
| free(data); |
| |
| Read(read); |
| EXPECT_EQ(read.glCopyTexImage2D, read.function()); |
| EXPECT_EQ(read.AfterCall, read.type()); |
| |
| CheckNoAvailable(); |
| } |