Build fix: Unit test code cleanup

- Added EXPECT_GLENUM_EQ to solve signed/unsigned comparisons
- Added createProgram and drawQuad utility functions to reduce
  code duplication

Change-Id: I8a62110346de501a1a77ec9688cf06b321385661
Reviewed-on: https://swiftshader-review.googlesource.com/17668
Tested-by: Alexis Hétu <sugoi@google.com>
Reviewed-by: Alexis Hétu <sugoi@google.com>

diff --git a/tests/unittests/unittests.cpp b/tests/unittests/unittests.cpp
index 7391e13..7ae84da 100644 (file)
--- a/tests/unittests/unittests.cpp
+++ b/tests/unittests/unittests.cpp
@@ -24,6 +24,8 @@
 #include <Windows.h>
 #endif
 
+#define EXPECT_GLENUM_EQ(expected, actual) EXPECT_EQ(static_cast<GLenum>(expected), static_cast<GLenum>(actual))
+
 class SwiftShaderTest : public testing::Test
 {
 protected:
@@ -95,8 +97,6 @@ protected:
                        EGL_ALPHA_SIZE,                 8,
                        EGL_NONE
                };
-
-               EGLConfig config;
                EGLint num_config = -1;
                EGLBoolean success = eglChooseConfig(display, configAttributes, &config, 1, &num_config);
                EXPECT_EQ(EGL_SUCCESS, eglGetError());
@@ -165,7 +165,7 @@ protected:
                        EXPECT_EQ(context, currentContext);
                }
 
-               EXPECT_EQ((GLenum)GL_NO_ERROR, glGetError());
+               EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
        }
 
        void Uninitialize()
@@ -203,8 +203,71 @@ protected:
                EXPECT_EQ((EGLBoolean)EGL_TRUE, success);
        }
 
+       GLuint createProgram(const std::string& vs, const std::string& fs)
+       {
+               GLuint program = glCreateProgram();
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+
+               GLuint vsShader = glCreateShader(GL_VERTEX_SHADER);
+               const char* vsSource[1] = { vs.c_str() };
+               glShaderSource(vsShader, 1, vsSource, nullptr);
+               glCompileShader(vsShader);
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+
+               GLuint fsShader = glCreateShader(GL_FRAGMENT_SHADER);
+               const char* fsSource[1] = { fs.c_str() };
+               glShaderSource(fsShader, 1, fsSource, nullptr);
+               glCompileShader(fsShader);
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+
+               glAttachShader(program, vsShader);
+               glAttachShader(program, fsShader);
+               glLinkProgram(program);
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+
+               return program;
+       }
+
+       void drawQuad(GLuint program)
+       {
+               GLint prevProgram = 0;
+               glGetIntegerv(GL_CURRENT_PROGRAM, &prevProgram);
+
+               glUseProgram(program);
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+
+               GLint posLoc = glGetAttribLocation(program, "position");
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+
+               GLint location = glGetUniformLocation(program, "tex");
+               ASSERT_NE(-1, location);
+               glUniform1i(location, 0);
+
+               float vertices[18] = { -1.0f,  1.0f, 0.5f,
+                                      -1.0f, -1.0f, 0.5f,
+                                       1.0f, -1.0f, 0.5f,
+                                      -1.0f,  1.0f, 0.5f,
+                                       1.0f, -1.0f, 0.5f,
+                                       1.0f,  1.0f, 0.5f };
+
+               glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, vertices);
+               glEnableVertexAttribArray(posLoc);
+               glDrawArrays(GL_TRIANGLES, 0, 6);
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+
+               glVertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
+               glDisableVertexAttribArray(posLoc);
+               glUseProgram(prevProgram);
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
+       }
+
+       EGLDisplay getDisplay() const { return display; }
+       EGLDisplay getConfig() const { return config; }
+       EGLSurface getSurface() const { return surface; }
+       EGLContext getContext() const { return context; }
 private:
        EGLDisplay display;
+       EGLConfig config;
        EGLSurface surface;
        EGLContext context;
 };
@@ -214,15 +277,15 @@ TEST_F(SwiftShaderTest, Initalization)
        Initialize(2, true);
 
        const GLubyte *glVendor = glGetString(GL_VENDOR);
-       EXPECT_EQ((GLenum)GL_NO_ERROR, glGetError());
+       EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
        EXPECT_STREQ("Google Inc.", (const char*)glVendor);
 
        const GLubyte *glRenderer = glGetString(GL_RENDERER);
-       EXPECT_EQ((GLenum)GL_NO_ERROR, glGetError());
+       EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
        EXPECT_STREQ("Google SwiftShader", (const char*)glRenderer);
 
        const GLubyte *glVersion = glGetString(GL_VERSION);
-       EXPECT_EQ((GLenum)GL_NO_ERROR, glGetError());
+       EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
        EXPECT_THAT((const char*)glVersion, testing::HasSubstr("OpenGL ES 2.0 SwiftShader "));
 
        Uninitialize();
@@ -262,11 +325,11 @@ TEST_F(SwiftShaderTest, TextureRectangle_TexImage2D)
 
        // Defining level 0 is allowed
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        // Defining level other than 0 is not allowed
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-       EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
 
        GLint maxSize = 0;
        glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &maxSize);
@@ -280,9 +343,9 @@ TEST_F(SwiftShaderTest, TextureRectangle_TexImage2D)
 
        // Defining a texture larger than the max size is disallowed
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, maxSize + 1, maxSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-       EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, maxSize, maxSize + 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-       EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
 
        Uninitialize();
 }
@@ -299,7 +362,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_CompressedTexImage2DDisallowed)
                GLuint tex = 1;
                glBindTexture(GL_TEXTURE_2D, tex);
                glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16, 0, 128, data);
-               EXPECT_EQ(GL_NONE, glGetError());
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
        }
 
        // Rectangle textures cannot be compressed
@@ -307,7 +370,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_CompressedTexImage2DDisallowed)
                GLuint tex = 2;
                glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
                glCompressedTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16, 0, 128, data);
-               EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+               EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
        }
 
        Uninitialize();
@@ -323,7 +386,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_TexStorage2D)
                GLuint tex = 1;
                glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
                glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8UI, 16, 16);
-               EXPECT_EQ(GL_NONE, glGetError());
+               EXPECT_GLENUM_EQ(GL_NONE, glGetError());
        }
 
        // Having more than one level is not allowed
@@ -333,7 +396,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_TexStorage2D)
                // Use 5 levels because the EXT_texture_storage extension requires a mip chain all the way
                // to a 1x1 mip.
                glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 5, GL_RGBA8UI, 16, 16);
-               EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+               EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
        }
 
        GLint maxSize = 0;
@@ -353,16 +416,16 @@ TEST_F(SwiftShaderTest, TextureRectangle_TexStorage2D)
                GLuint tex = 4;
                glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
                glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8UI, maxSize + 1, maxSize);
-               EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+               EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
                glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8UI, maxSize, maxSize + 1);
-               EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+               EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
        }
 
        // Compressed formats are disallowed
        GLuint tex = 5;
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
        glTexStorage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
 
        Uninitialize();
 }
@@ -378,39 +441,39 @@ TEST_F(SwiftShaderTest, TextureRectangle_TexParameterRestriction)
        // Only wrap mode CLAMP_TO_EDGE is supported
        // Wrap S
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_REPEAT);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
 
        // Wrap T
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_REPEAT);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
 
        // Min filter has to be nearest or linear
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-       EXPECT_EQ(GL_INVALID_ENUM, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_ENUM, glGetError());
 
        // Base level has to be 0
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 0);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BASE_LEVEL, 1);
-       EXPECT_EQ(GL_INVALID_OPERATION, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_OPERATION, glGetError());
 
        Uninitialize();
 }
@@ -423,19 +486,19 @@ TEST_F(SwiftShaderTest, TextureRectangle_FramebufferTexture2DLevel)
        GLuint tex = 1;
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        GLuint fbo = 1;
        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 
        // Using level 0 of a rectangle texture is valid.
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 0);
-       EXPECT_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        // Setting level != 0 is invalid
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 1);
-       EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
 
        Uninitialize();
 }
@@ -447,11 +510,11 @@ TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangle)
 
        GLuint tex = 1;
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        unsigned char green[4] = { 0, 255, 0, 255 };
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, green);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        const std::string vs =
                "attribute vec4 position;\n"
@@ -469,25 +532,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangle)
                "    gl_FragColor = texture2DRect(tex, vec2(0, 0));\n"
                "}\n";
 
-       GLuint program = glCreateProgram();
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       GLuint vsShader = glCreateShader(GL_VERTEX_SHADER);
-       const char* vsSource[1] = { vs.c_str() };
-       glShaderSource(vsShader, 1, vsSource, nullptr);
-       glCompileShader(vsShader);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       GLuint fsShader = glCreateShader(GL_FRAGMENT_SHADER);
-       const char* fsSource[1] = { fs.c_str() };
-       glShaderSource(fsShader, 1, fsSource, nullptr);
-       glCompileShader(fsShader);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       glAttachShader(program, vsShader);
-       glAttachShader(program, fsShader);
-       glLinkProgram(program);
-       EXPECT_EQ(GL_NONE, glGetError());
+       GLuint program = createProgram(vs, fs);
 
        glUseProgram(program);
        GLint location = glGetUniformLocation(program, "tex");
@@ -496,36 +541,13 @@ TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangle)
 
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       GLint prevProgram = 0;
-       glGetIntegerv(GL_CURRENT_PROGRAM, &prevProgram);
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-       glUseProgram(program);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       GLint posLoc = glGetAttribLocation(program, "position");
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       float vertices[18] = { -1.0f,  1.0f, 0.5f,
-                                                  -1.0f, -1.0f, 0.5f,
-                                                       1.0f, -1.0f, 0.5f,
-                                                  -1.0f,  1.0f, 0.5f,
-                                                       1.0f, -1.0f, 0.5f,
-                                                       1.0f,  1.0f, 0.5f };
-       glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, vertices);
-       glEnableVertexAttribArray(posLoc);
-       glDrawArrays(GL_TRIANGLES, 0, 6);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       glVertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
-       glDisableVertexAttribArray(posLoc);
-       glUseProgram(prevProgram);
-       EXPECT_EQ(GL_NONE, glGetError());
+       drawQuad(program);
 
        compareColor(green);
 
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        Uninitialize();
 }
@@ -537,11 +559,11 @@ TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangleESSL3)
 
        GLuint tex = 1;
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, tex);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        unsigned char green[4] = { 0, 255, 0, 255 };
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, green);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        const std::string vs =
                "#version 300 es\n"
@@ -562,26 +584,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangleESSL3)
                "    fragColor = texture(tex, vec2(0, 0));\n"
                "}\n";
 
-       GLuint program = glCreateProgram();
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       GLuint vsShader = glCreateShader(GL_VERTEX_SHADER);
-       const char* vsSource[1] = { vs.c_str() };
-       glShaderSource(vsShader, 1, vsSource, nullptr);
-       glCompileShader(vsShader);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       GLuint fsShader = glCreateShader(GL_FRAGMENT_SHADER);
-       const char* fsSource[1] = { fs.c_str() };
-       glShaderSource(fsShader, 1, fsSource, nullptr);
-       glCompileShader(fsShader);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       glAttachShader(program, vsShader);
-       glAttachShader(program, fsShader);
-       glLinkProgram(program);
-       EXPECT_EQ(GL_NONE, glGetError());
-
+       GLuint program = createProgram(vs, fs);
        glUseProgram(program);
        GLint location = glGetUniformLocation(program, "tex");
        ASSERT_NE(-1, location);
@@ -589,36 +592,13 @@ TEST_F(SwiftShaderTest, TextureRectangle_SamplingFromRectangleESSL3)
 
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-       GLint prevProgram = 0;
-       glGetIntegerv(GL_CURRENT_PROGRAM, &prevProgram);
-
-       glUseProgram(program);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       GLint posLoc = glGetAttribLocation(program, "position");
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       float vertices[18] = { -1.0f,  1.0f, 0.5f,
-                                                  -1.0f, -1.0f, 0.5f,
-                                                       1.0f, -1.0f, 0.5f,
-                                                  -1.0f,  1.0f, 0.5f,
-                                                       1.0f, -1.0f, 0.5f,
-                                                       1.0f,  1.0f, 0.5f };
-       glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, vertices);
-       glEnableVertexAttribArray(posLoc);
-       glDrawArrays(GL_TRIANGLES, 0, 6);
-       EXPECT_EQ(GL_NONE, glGetError());
-
-       glVertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
-       glDisableVertexAttribArray(posLoc);
-       glUseProgram(prevProgram);
-       EXPECT_EQ(GL_NONE, glGetError());
+       drawQuad(program);
 
        compareColor(green);
 
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        Uninitialize();
 }
@@ -636,8 +616,8 @@ TEST_F(SwiftShaderTest, TextureRectangle_RenderToRectangle)
        GLuint fbo = 1;
        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, tex, 0);
-       EXPECT_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        // Clearing a texture is just as good as checking we can render to it, right?
        glClearColor(0.0, 1.0, 0.0, 1.0);
@@ -645,7 +625,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_RenderToRectangle)
 
        unsigned char green[4] = { 0, 255, 0, 255 };
        compareColor(green);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        Uninitialize();
 }
@@ -659,15 +639,15 @@ TEST_F(SwiftShaderTest, TextureRectangle_DefaultSamplerParameters)
 
        GLint minFilter = 0;
        glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, &minFilter);
-       EXPECT_EQ(GL_LINEAR, minFilter);
+       EXPECT_GLENUM_EQ(GL_LINEAR, minFilter);
 
        GLint wrapS = 0;
        glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, &wrapS);
-       EXPECT_EQ(GL_CLAMP_TO_EDGE, wrapS);
+       EXPECT_GLENUM_EQ(GL_CLAMP_TO_EDGE, wrapS);
 
        GLint wrapT = 0;
        glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, &wrapT);
-       EXPECT_EQ(GL_CLAMP_TO_EDGE, wrapT);
+       EXPECT_GLENUM_EQ(GL_CLAMP_TO_EDGE, wrapT);
 
        Uninitialize();
 }
@@ -683,15 +663,15 @@ TEST_F(SwiftShaderTest, TextureRectangle_CopyTexImage)
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        glClearColor(0, 1, 0, 1);
        glClear(GL_COLOR_BUFFER_BIT);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        // Error case: level != 0
        glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 1, GL_RGBA8, 0, 0, 1, 1, 0);
-       EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
 
        // level = 0 works and defines the texture.
        glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, 0, 0, 1, 1, 0);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        GLuint fbo = 1;
        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
@@ -699,7 +679,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_CopyTexImage)
 
        unsigned char green[4] = { 0, 255, 0, 255 };
        compareColor(green);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        Uninitialize();
 }
@@ -717,15 +697,15 @@ TEST_F(SwiftShaderTest, TextureRectangle_CopyTexSubImage)
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        glClearColor(0, 1, 0, 1);
        glClear(GL_COLOR_BUFFER_BIT);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        // Error case: level != 0
        glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 1, 0, 0, 0, 0, 1, 1);
-       EXPECT_EQ(GL_INVALID_VALUE, glGetError());
+       EXPECT_GLENUM_EQ(GL_INVALID_VALUE, glGetError());
 
        // level = 0 works and defines the texture.
        glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, 0, 0, 1, 1);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        GLuint fbo = 1;
        glBindFramebuffer(GL_FRAMEBUFFER, fbo);
@@ -733,7 +713,7 @@ TEST_F(SwiftShaderTest, TextureRectangle_CopyTexSubImage)
 
        unsigned char green[4] = { 0, 255, 0, 255 };
        compareColor(green);
-       EXPECT_EQ(GL_NONE, glGetError());
+       EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
        Uninitialize();
 }