Clean up coding style issues in InstancingTest.cpp

src/tests/gl_tests/InstancingTest.cpp

@@ -5,6 +5,7 @@
 //
 
 #include "test_utils/ANGLETest.h"
+#include "test_utils/gl_raii.h"
 
 using namespace angle;
 
@@ -35,32 +36,35 @@ class InstancingTest : public ANGLETest
         mDrawArraysInstancedANGLE   = nullptr;
         mDrawElementsInstancedANGLE = nullptr;
 
-        char *extensionString = (char*)glGetString(GL_EXTENSIONS);
+        const char *extensionString = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
         if (strstr(extensionString, "GL_ANGLE_instanced_arrays"))
         {
-            mVertexAttribDivisorANGLE = (PFNGLVERTEXATTRIBDIVISORANGLEPROC)eglGetProcAddress("glVertexAttribDivisorANGLE");
-            mDrawArraysInstancedANGLE = (PFNGLDRAWARRAYSINSTANCEDANGLEPROC)eglGetProcAddress("glDrawArraysInstancedANGLE");
-            mDrawElementsInstancedANGLE = (PFNGLDRAWELEMENTSINSTANCEDANGLEPROC)eglGetProcAddress("glDrawElementsInstancedANGLE");
+            mVertexAttribDivisorANGLE =
+                (PFNGLVERTEXATTRIBDIVISORANGLEPROC)eglGetProcAddress("glVertexAttribDivisorANGLE");
+            mDrawArraysInstancedANGLE =
+                (PFNGLDRAWARRAYSINSTANCEDANGLEPROC)eglGetProcAddress("glDrawArraysInstancedANGLE");
+            mDrawElementsInstancedANGLE = (PFNGLDRAWELEMENTSINSTANCEDANGLEPROC)eglGetProcAddress(
+                "glDrawElementsInstancedANGLE");
         }
 
-        ASSERT_TRUE(mVertexAttribDivisorANGLE != nullptr);
-        ASSERT_TRUE(mDrawArraysInstancedANGLE != nullptr);
-        ASSERT_TRUE(mDrawElementsInstancedANGLE != nullptr);
+        ASSERT_NE(nullptr, mVertexAttribDivisorANGLE);
+        ASSERT_NE(nullptr, mDrawArraysInstancedANGLE);
+        ASSERT_NE(nullptr, mDrawElementsInstancedANGLE);
 
         // Initialize the vertex and index vectors
-        GLfloat qvertex1[3] = {-quadRadius,  quadRadius, 0.0f};
-        GLfloat qvertex2[3] = {-quadRadius, -quadRadius, 0.0f};
-        GLfloat qvertex3[3] = { quadRadius, -quadRadius, 0.0f};
-        GLfloat qvertex4[3] = { quadRadius,  quadRadius, 0.0f};
+        constexpr GLfloat qvertex1[3] = {-quadRadius, quadRadius, 0.0f};
+        constexpr GLfloat qvertex2[3] = {-quadRadius, -quadRadius, 0.0f};
+        constexpr GLfloat qvertex3[3] = {quadRadius, -quadRadius, 0.0f};
+        constexpr GLfloat qvertex4[3] = {quadRadius, quadRadius, 0.0f};
         mQuadVertices.insert(mQuadVertices.end(), qvertex1, qvertex1 + 3);
         mQuadVertices.insert(mQuadVertices.end(), qvertex2, qvertex2 + 3);
         mQuadVertices.insert(mQuadVertices.end(), qvertex3, qvertex3 + 3);
         mQuadVertices.insert(mQuadVertices.end(), qvertex4, qvertex4 + 3);
 
-        GLfloat coord1[2] = {0.0f, 0.0f};
-        GLfloat coord2[2] = {0.0f, 1.0f};
-        GLfloat coord3[2] = {1.0f, 1.0f};
-        GLfloat coord4[2] = {1.0f, 0.0f};
+        constexpr GLfloat coord1[2] = {0.0f, 0.0f};
+        constexpr GLfloat coord2[2] = {0.0f, 1.0f};
+        constexpr GLfloat coord3[2] = {1.0f, 1.0f};
+        constexpr GLfloat coord4[2] = {1.0f, 0.0f};
         mTexcoords.insert(mTexcoords.end(), coord1, coord1 + 2);
         mTexcoords.insert(mTexcoords.end(), coord2, coord2 + 2);
         mTexcoords.insert(mTexcoords.end(), coord3, coord3 + 2);
@@ -92,7 +96,7 @@ class InstancingTest : public ANGLETest
         {
             for (float x = -1.0f + quadRadius; x < 1.0f - quadRadius; x += quadRadius * 3)
             {
-                GLfloat instance[3] = {x + quadRadius, y + quadRadius, 0.0f};
+                const GLfloat instance[3] = {x + quadRadius, y + quadRadius, 0.0f};
                 mInstances.insert(mInstances.end(), instance, instance + 3);
             }
         }
@@ -106,14 +110,12 @@ class InstancingTest : public ANGLETest
 
     void setupDrawArraysTest(const std::string &vs)
     {
-        const std::string fs = SHADER_SOURCE
-        (
-            precision mediump float;
-            void main()
-            {
-                gl_FragColor = vec4(1.0, 0, 0, 1.0);
-            }
-        );
+        const std::string fs =
+            "precision mediump float;\n"
+            "void main()\n"
+            "{\n"
+            "    gl_FragColor = vec4(1.0, 0, 0, 1.0);\n"
+            "}\n";
 
         mProgram = CompileProgram(vs, fs);
         ASSERT_NE(0u, mProgram);
@@ -137,26 +139,22 @@ class InstancingTest : public ANGLETest
         mIndices.push_back(3);
 
         // clang-format off
-        const std::string vs = SHADER_SOURCE
-        (
-            attribute vec3 a_position;
-            attribute vec3 a_instancePos;
-            void main()
-            {
-                gl_Position  = vec4(a_position.xyz, 1.0);
-                gl_Position  = vec4(a_instancePos.xyz, 1.0);
-                gl_PointSize = 6.0;
-            }
-        );
-
-        const std::string fs = SHADER_SOURCE
-        (
-            precision mediump float;
-            void main()
-            {
-                gl_FragColor = vec4(1.0, 0, 0, 1.0);
-            }
-        );
+        const std::string vs =
+            "attribute vec3 a_position;\n"
+            "attribute vec3 a_instancePos;\n"
+            "void main()\n"
+            "{\n"
+            "    gl_Position  = vec4(a_position.xyz, 1.0);\n"
+            "    gl_Position  = vec4(a_instancePos.xyz, 1.0);\n"
+            "    gl_PointSize = 6.0;\n"
+            "}\n";
+
+        const std::string fs =
+            "precision mediump float;\n"
+            "void main()\n"
+            "{\n"
+            "    gl_FragColor = vec4(1.0, 0, 0, 1.0);\n"
+            "}\n";
         // clang-format on
 
         mProgram = CompileProgram(vs, fs);
@@ -172,10 +170,11 @@ class InstancingTest : public ANGLETest
         glUseProgram(mProgram);
     }
 
-    void runDrawArraysTest(GLint first, GLsizei count, GLsizei instanceCount, float *offset)
+    void runDrawArraysTest(GLint first, GLsizei count, GLsizei instanceCount, const float *offset)
     {
         glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
-        glBufferData(GL_ARRAY_BUFFER, mInstances.size() * sizeof(mInstances[0]), &mInstances[0], GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, mInstances.size() * sizeof(mInstances[0]), &mInstances[0],
+                     GL_STATIC_DRAW);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
 
         // Get the attribute locations
@@ -197,7 +196,7 @@ class InstancingTest : public ANGLETest
 
         // Offset
         GLint uniformLoc = glGetUniformLocation(mProgram, "u_offset");
-        ASSERT_NE(uniformLoc, -1);
+        ASSERT_NE(-1, uniformLoc);
         glUniform3fv(uniformLoc, 1, offset);
 
         // Do the instanced draw
@@ -208,17 +207,14 @@ class InstancingTest : public ANGLETest
 
     virtual void runDrawElementsTest(std::string vs, bool shouldAttribZeroBeInstanced)
     {
-        const std::string fs = SHADER_SOURCE
-        (
-            precision mediump float;
-            void main()
-            {
-                gl_FragColor = vec4(1.0, 0, 0, 1.0);
-            }
-        );
+        const std::string fs =
+            "precision mediump float;\n"
+            "void main()\n"
+            "{\n"
+            "    gl_FragColor = vec4(1.0, 0, 0, 1.0);\n"
+            "}\n";
 
-        GLuint program = CompileProgram(vs, fs);
-        ASSERT_NE(program, 0u);
+        ANGLE_GL_PROGRAM(program, vs, fs);
 
         // Get the attribute locations
         GLint positionLoc = glGetAttribLocation(program, "a_position");
@@ -264,8 +260,10 @@ class InstancingTest : public ANGLETest
         {
             unsigned int baseOffset = quadIndex * 3;
 
-            int quadx = static_cast<int>(((mInstances[baseOffset + 0]) * 0.5f + 0.5f) * getWindowWidth());
-            int quady = static_cast<int>(((mInstances[baseOffset + 1]) * 0.5f + 0.5f) * getWindowHeight());
+            int quadx =
+                static_cast<int>(((mInstances[baseOffset + 0]) * 0.5f + 0.5f) * getWindowWidth());
+            int quady =
+                static_cast<int>(((mInstances[baseOffset + 1]) * 0.5f + 0.5f) * getWindowHeight());
 
             EXPECT_PIXEL_EQ(quadx, quady, 255, 0, 0, 255);
         }
@@ -283,7 +281,7 @@ class InstancingTest : public ANGLETest
     std::vector<GLfloat> mInstances;
     std::vector<GLushort> mIndices;
 
-    const GLfloat quadRadius = 0.30f;
+    static constexpr GLfloat quadRadius = 0.30f;
 
     GLuint mProgram;
     GLuint mVertexBuffer;
@@ -308,36 +306,33 @@ class InstancingTestPoints : public InstancingTest
 };
 
 // This test uses a vertex shader with the first attribute (attribute zero) instanced.
-// On D3D9 and D3D11 FL9_3, this triggers a special codepath that rearranges the input layout sent to D3D,
-// to ensure that slot/stream zero of the input layout doesn't contain per-instance data.
+// On D3D9 and D3D11 FL9_3, this triggers a special codepath that rearranges the input layout sent
+// to D3D, to ensure that slot/stream zero of the input layout doesn't contain per-instance data.
 TEST_P(InstancingTestAllConfigs, AttributeZeroInstanced)
 {
-    const std::string vs = SHADER_SOURCE
-    (
-        attribute vec3 a_instancePos;
-        attribute vec3 a_position;
-        void main()
-        {
-            gl_Position = vec4(a_position.xyz + a_instancePos.xyz, 1.0);
-        }
-    );
+    const std::string vs =
+        "attribute vec3 a_instancePos;\n"
+        "attribute vec3 a_position;\n"
+        "void main()\n"
+        "{\n"
+        "    gl_Position = vec4(a_position.xyz + a_instancePos.xyz, 1.0);\n"
+        "}\n";
 
     runDrawElementsTest(vs, true);
 }
 
 // Same as AttributeZeroInstanced, but attribute zero is not instanced.
-// This ensures the general instancing codepath (i.e. without rearranging the input layout) works as expected.
+// This ensures the general instancing codepath (i.e. without rearranging the input layout) works as
+// expected.
 TEST_P(InstancingTestAllConfigs, AttributeZeroNotInstanced)
 {
-    const std::string vs = SHADER_SOURCE
-    (
-        attribute vec3 a_position;
-        attribute vec3 a_instancePos;
-        void main()
-        {
-            gl_Position = vec4(a_position.xyz + a_instancePos.xyz, 1.0);
-        }
-    );
+    const std::string vs =
+        "attribute vec3 a_position;\n"
+        "attribute vec3 a_instancePos;\n"
+        "void main()\n"
+        "{\n"
+        "    gl_Position = vec4(a_position.xyz + a_instancePos.xyz, 1.0);\n"
+        "}\n";
 
     runDrawElementsTest(vs, false);
 }
@@ -346,23 +341,21 @@ TEST_P(InstancingTestAllConfigs, AttributeZeroNotInstanced)
 // the non-instanced vertex attributes.
 TEST_P(InstancingTestNo9_3, DrawArraysWithOffset)
 {
-    const std::string vs = SHADER_SOURCE
-    (
-        attribute vec3 a_position;
-        attribute vec3 a_instancePos;
-        uniform vec3 u_offset;
-        void main()
-        {
-            gl_Position = vec4(a_position.xyz + a_instancePos.xyz + u_offset, 1.0);
-        }
-    );
+    const std::string vs =
+        "attribute vec3 a_position;\n"
+        "attribute vec3 a_instancePos;\n"
+        "uniform vec3 u_offset;\n"
+        "void main()\n"
+        "{\n"
+        "    gl_Position = vec4(a_position.xyz + a_instancePos.xyz + u_offset, 1.0);\n"
+        "}\n";
 
     setupDrawArraysTest(vs);
 
-    float offset1[3] = { 0, 0, 0 };
+    constexpr float offset1[3] = {0, 0, 0};
     runDrawArraysTest(0, 6, 2, offset1);
 
-    float offset2[3] = { 0.0f, 1.0f, 0 };
+    constexpr float offset2[3] = {0.0f, 1.0f, 0};
     runDrawArraysTest(6, 6, 2, offset2);
 
     checkQuads();
@@ -389,7 +382,7 @@ TEST_P(InstancingTestPoints, DrawArrays)
     GLint instancePosLoc = glGetAttribLocation(mProgram, "a_instancePos");
 
     // Load the vertex position
-    GLfloat pos[3] = {0, 0, 0};
+    constexpr GLfloat pos[3] = {0, 0, 0};
     glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, pos);
     glEnableVertexAttribArray(positionLoc);
 
@@ -431,7 +424,7 @@ TEST_P(InstancingTestPoints, DrawElements)
     GLint instancePosLoc = glGetAttribLocation(mProgram, "a_instancePos");
 
     // Load the vertex position
-    Vector3 pos[] = {Vector3(0), Vector3(0), Vector3(0), Vector3(0)};
+    const Vector3 pos[] = {Vector3(0), Vector3(0), Vector3(0), Vector3(0)};
     glVertexAttribPointer(positionLoc, 3, GL_FLOAT, GL_FALSE, 0, pos);
     glEnableVertexAttribArray(positionLoc);
 
@@ -453,8 +446,9 @@ TEST_P(InstancingTestPoints, DrawElements)
     checkQuads();
 }
 
-// Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-// We test on D3D9 and D3D11 9_3 because they use special codepaths when attribute zero is instanced, unlike D3D11.
+// Use this to select which configurations (e.g. which renderer, which GLES major version) these
+// tests should be run against. We test on D3D9 and D3D11 9_3 because they use special codepaths
+// when attribute zero is instanced, unlike D3D11.
 ANGLE_INSTANTIATE_TEST(InstancingTestAllConfigs,
                        ES2_D3D9(),
                        ES2_D3D11(),