Enable all angle_end2end_tests targeting OpenGL and OpenGL ES backends.

src/tests/gl_tests/BlendMinMaxTest.cpp

@@ -166,9 +166,10 @@ TEST_P(BlendMinMaxTest, RGBA8)
 
 TEST_P(BlendMinMaxTest, RGBA32f)
 {
-    if (getClientVersion() < 3 && !extensionEnabled("GL_OES_texture_float"))
+    if (getClientVersion() < 3 || !extensionEnabled("GL_EXT_color_buffer_float"))
     {
-        std::cout << "Test skipped because ES3 or GL_OES_texture_float is not available." << std::endl;
+        std::cout << "Test skipped because ES3 and GL_EXT_color_buffer_float are not available."
+                  << std::endl;
         return;
     }
 
@@ -205,8 +206,21 @@ TEST_P(BlendMinMaxTest, RGBA16F)
         return;
     }
 
+    // TODO(geofflang): This fails because readpixels with UNSIGNED_BYTE/RGBA does not work with
+    // half float buffers (http://anglebug.com/1288)
+    if (GetParam().getRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)
+    {
+        std::cout << "Test skipped on OpenGL ES targets." << std::endl;
+        return;
+    }
+
     runTest(GL_RGBA16F);
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(BlendMinMaxTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(BlendMinMaxTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());

src/tests/gl_tests/BlitFramebufferANGLETest.cpp

@@ -888,5 +888,8 @@ TEST_P(BlitFramebufferANGLETest, Errors)
 
 }
 
+// TODO(geofflang): Fix the dependence on glBlitFramebufferANGLE without checks and assuming the
+// default framebuffer is BGRA to enable the GL and GLES backends. (http://anglebug.com/1289)
+
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 ANGLE_INSTANTIATE_TEST(BlitFramebufferANGLETest, ES2_D3D9(), ES2_D3D11());

src/tests/gl_tests/BufferDataTest.cpp

@@ -287,6 +287,13 @@ class IndexedBufferCopyTest : public ANGLETest
 // https://code.google.com/p/angleproject/issues/detail?id=709
 TEST_P(IndexedBufferCopyTest, IndexRangeBug)
 {
+    // TODO(geofflang): Figure out why this fails on AMD OpenGL (http://anglebug.com/1291)
+    if (isAMD() && getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on AMD OpenGL." << std::endl;
+        return;
+    }
+
     unsigned char vertexData[] = { 255, 0, 0, 0, 0, 0 };
     unsigned int indexData[] = { 0, 1 };
 
@@ -401,9 +408,9 @@ TEST_P(BufferDataTestES3, BufferResizing)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(BufferDataTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL());
-ANGLE_INSTANTIATE_TEST(BufferDataTestES3, ES3_D3D11());
-ANGLE_INSTANTIATE_TEST(IndexedBufferCopyTest, ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(BufferDataTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(BufferDataTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(IndexedBufferCopyTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
 
 #ifdef _WIN64
 

src/tests/gl_tests/ClearTest.cpp

@@ -312,5 +312,12 @@ TEST_P(ClearTestES3, MixedSRGBClear)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(ClearTest, ES2_D3D9(), ES2_D3D11(), ES3_D3D11(), ES2_OPENGL(), ES3_OPENGL());
-ANGLE_INSTANTIATE_TEST(ClearTestES3, ES3_D3D11(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(ClearTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(ClearTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());

src/tests/gl_tests/CompressedTextureTest.cpp

@@ -302,11 +302,16 @@ TEST_P(CompressedTextureTestD3D11, PBOCompressedTexStorage)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(
-    CompressedTextureTest,
-    ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(CompressedTextureTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(CompressedTextureTestES3, ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(CompressedTextureTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
 
 ANGLE_INSTANTIATE_TEST(CompressedTextureTestD3D11, ES2_D3D11(), ES3_D3D11(), ES2_D3D11_FL9_3());

src/tests/gl_tests/CopyTexImageTest.cpp

@@ -300,5 +300,10 @@ TEST_P(CopyTexImageTest, SubImageRGBToL)
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against.
-ANGLE_INSTANTIATE_TEST(CopyTexImageTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGL(3, 3));
+ANGLE_INSTANTIATE_TEST(CopyTexImageTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_OPENGL(),
+                       ES2_OPENGL(3, 3),
+                       ES2_OPENGLES());
 }

src/tests/gl_tests/CubeMapTextureTest.cpp

@@ -129,4 +129,10 @@ TEST_P(CubeMapTextureTest, RenderToFacesConsecutively)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(CubeMapTextureTest, ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(CubeMapTextureTest,
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());

src/tests/gl_tests/DebugMarkerTest.cpp

@@ -66,6 +66,6 @@ TEST_P(DebugMarkerTest, BasicValidation)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(DebugMarkerTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(DebugMarkerTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES());
 
 } // namespace

src/tests/gl_tests/DepthStencilFormatsTest.cpp

@@ -184,5 +184,9 @@ TEST_P(DepthStencilFormatsTestES3, DrawWithDepthStencil)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(DepthStencilFormatsTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL());
-ANGLE_INSTANTIATE_TEST(DepthStencilFormatsTestES3, ES3_D3D11(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(DepthStencilFormatsTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(DepthStencilFormatsTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());

src/tests/gl_tests/DiscardFramebufferEXTTest.cpp

@@ -133,4 +133,11 @@ TEST_P(DiscardFramebufferEXTTest, NonDefaultFramebuffer)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(DiscardFramebufferEXTTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(DiscardFramebufferEXTTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());

src/tests/gl_tests/DrawBuffersTest.cpp

@@ -354,4 +354,11 @@ TEST_P(DrawBuffersTest, UnwrittenOutputVariablesShouldNotCrash)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(DrawBuffersTest, ES2_D3D11(), ES3_D3D11(), ES2_D3D11_FL9_3());
+ANGLE_INSTANTIATE_TEST(DrawBuffersTest,
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());

src/tests/gl_tests/DrawElementsTest.cpp

@@ -222,5 +222,5 @@ TEST_P(DrawElementsTest, DeletingAfterStreamingIndexes)
     ASSERT_GL_NO_ERROR();
 }
 
-ANGLE_INSTANTIATE_TEST(DrawElementsTest, ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(DrawElementsTest, ES3_OPENGL(), ES3_OPENGLES());
 }

src/tests/gl_tests/FenceSyncTests.cpp

@@ -271,5 +271,12 @@ TEST_P(FenceSyncTest, BasicOperations)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(FenceNVTest, ES2_D3D9(), ES2_D3D11(), ES3_D3D11(), ES2_OPENGL(), ES3_OPENGL());
-ANGLE_INSTANTIATE_TEST(FenceSyncTest, ES3_D3D11(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(FenceNVTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(FenceSyncTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());

src/tests/gl_tests/FramebufferFormatsTest.cpp

@@ -291,4 +291,11 @@ TEST_P(FramebufferFormatsTest, IncompleteCubeMap)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(FramebufferFormatsTest, ES2_D3D9(), ES2_D3D11(), ES3_D3D11(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(FramebufferFormatsTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());

src/tests/gl_tests/FramebufferRenderMipmapTest.cpp

@@ -197,4 +197,11 @@ TEST_P(FramebufferRenderMipmapTest, RenderToMipmap)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(FramebufferRenderMipmapTest, ES2_D3D9(), ES2_D3D11(), ES3_D3D11(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(FramebufferRenderMipmapTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());

src/tests/gl_tests/GLSLTest.cpp

@@ -462,6 +462,24 @@ TEST_P(GLSLTest, NamelessScopedStructs)
 
 TEST_P(GLSLTest, ScopedStructsOrderBug)
 {
+#if defined(__APPLE__)
+    // TODO(geofflang): Find out why this doesn't compile on Apple OpenGL drivers
+    // (http://anglebug.com/1292)
+    if (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on Apple OpenGL." << std::endl;
+        return;
+    }
+#elif defined(_WIN32)
+    // TODO(geofflang): Find out why this doesn't compile on Windows AMD OpenGL drivers
+    // (http://anglebug.com/1291)
+    if (isAMD() && getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on Windows AMD OpenGL." << std::endl;
+        return;
+    }
+#endif
+
     const std::string fragmentShaderSource = SHADER_SOURCE
     (
         precision mediump float;
@@ -616,6 +634,14 @@ TEST_P(GLSLTest, TwoElseIfRewriting)
 
 TEST_P(GLSLTest, InvariantVaryingOut)
 {
+    // TODO(geofflang): Some OpenGL drivers have compile errors when varyings do not have matching
+    // invariant attributes (http://anglebug.com/1293)
+    if (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on OpenGL." << std::endl;
+        return;
+    }
+
     const std::string fragmentShaderSource = SHADER_SOURCE
     (
         precision mediump float;
@@ -687,6 +713,14 @@ TEST_P(GLSLTest, FrontFacingAndVarying)
 
 TEST_P(GLSLTest, InvariantVaryingIn)
 {
+    // TODO(geofflang): Some OpenGL drivers have compile errors when varyings do not have matching
+    // invariant attributes (http://anglebug.com/1293)
+    if (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on OpenGL." << std::endl;
+        return;
+    }
+
     const std::string fragmentShaderSource = SHADER_SOURCE
     (
         precision mediump float;
@@ -748,6 +782,14 @@ TEST_P(GLSLTest, InvariantGLPosition)
 
 TEST_P(GLSLTest, InvariantAll)
 {
+    // TODO(geofflang): Some OpenGL drivers have compile errors when varyings do not have matching
+    // invariant attributes (http://anglebug.com/1293)
+    if (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on OpenGL." << std::endl;
+        return;
+    }
+
     const std::string fragmentShaderSource = SHADER_SOURCE
     (
         precision mediump float;
@@ -784,6 +826,13 @@ TEST_P(GLSLTest, MaxMinusTwoVaryingVec4PlusTwoSpecialVariables)
 
 TEST_P(GLSLTest, MaxMinusTwoVaryingVec4PlusThreeSpecialVariables)
 {
+    // TODO(geofflang): Figure out why this fails on OpenGL AMD (http://anglebug.com/1291)
+    if (isAMD() && getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on OpenGL." << std::endl;
+        return;
+    }
+
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 
@@ -791,7 +840,9 @@ TEST_P(GLSLTest, MaxMinusTwoVaryingVec4PlusThreeSpecialVariables)
     VaryingTestBase(0, 0, 0, 0, 0, 0, maxVaryings - 2, 0, true, true, true, true);
 }
 
-TEST_P(GLSLTest, MaxVaryingVec4PlusFragCoord)
+// Disabled because drivers are allowed to successfully compile shaders that have more than the
+// maximum number of varyings. (http://anglebug.com/1296)
+TEST_P(GLSLTest, DISABLED_MaxVaryingVec4PlusFragCoord)
 {
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
@@ -801,7 +852,9 @@ TEST_P(GLSLTest, MaxVaryingVec4PlusFragCoord)
     VaryingTestBase(0, 0, 0, 0, 0, 0, maxVaryings, 0, true, false, false, false);
 }
 
-TEST_P(GLSLTest, MaxVaryingVec4PlusPointCoord)
+// Disabled because drivers are allowed to successfully compile shaders that have more than the
+// maximum number of varyings. (http://anglebug.com/1296)
+TEST_P(GLSLTest, DISABLED_MaxVaryingVec4PlusPointCoord)
 {
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
@@ -866,6 +919,13 @@ TEST_P(GLSLTest, TwiceMaxVaryingVec2)
         return;
     }
 
+    if (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)
+    {
+        // TODO(geofflang): Figure out why this fails on NVIDIA's GLES driver
+        std::cout << "Test disabled on OpenGL ES." << std::endl;
+        return;
+    }
+
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 
@@ -881,13 +941,22 @@ TEST_P(GLSLTest, MaxVaryingVec2Arrays)
         return;
     }
 
+    if (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)
+    {
+        // TODO(geofflang): Figure out why this fails on NVIDIA's GLES driver
+        std::cout << "Test disabled on OpenGL ES." << std::endl;
+        return;
+    }
+
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 
     VaryingTestBase(0, 0, 0, maxVaryings, 0, 0, 0, 0, false, false, false, true);
 }
 
-TEST_P(GLSLTest, MaxPlusOneVaryingVec3)
+// Disabled because drivers are allowed to successfully compile shaders that have more than the
+// maximum number of varyings. (http://anglebug.com/1296)
+TEST_P(GLSLTest, DISABLED_MaxPlusOneVaryingVec3)
 {
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
@@ -895,7 +964,9 @@ TEST_P(GLSLTest, MaxPlusOneVaryingVec3)
     VaryingTestBase(0, 0, 0, 0, maxVaryings + 1, 0, 0, 0, false, false, false, false);
 }
 
-TEST_P(GLSLTest, MaxPlusOneVaryingVec3Array)
+// Disabled because drivers are allowed to successfully compile shaders that have more than the
+// maximum number of varyings. (http://anglebug.com/1296)
+TEST_P(GLSLTest, DISABLED_MaxPlusOneVaryingVec3Array)
 {
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
@@ -903,7 +974,9 @@ TEST_P(GLSLTest, MaxPlusOneVaryingVec3Array)
     VaryingTestBase(0, 0, 0, 0, 0, maxVaryings / 2 + 1, 0, 0, false, false, false, false);
 }
 
-TEST_P(GLSLTest, MaxVaryingVec3AndOneVec2)
+// Disabled because drivers are allowed to successfully compile shaders that have more than the
+// maximum number of varyings. (http://anglebug.com/1296)
+TEST_P(GLSLTest, DISABLED_MaxVaryingVec3AndOneVec2)
 {
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
@@ -911,7 +984,9 @@ TEST_P(GLSLTest, MaxVaryingVec3AndOneVec2)
     VaryingTestBase(0, 0, 1, 0, maxVaryings, 0, 0, 0, false, false, false, false);
 }
 
-TEST_P(GLSLTest, MaxPlusOneVaryingVec2)
+// Disabled because drivers are allowed to successfully compile shaders that have more than the
+// maximum number of varyings. (http://anglebug.com/1296)
+TEST_P(GLSLTest, DISABLED_MaxPlusOneVaryingVec2)
 {
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
@@ -919,7 +994,9 @@ TEST_P(GLSLTest, MaxPlusOneVaryingVec2)
     VaryingTestBase(0, 0, 2 * maxVaryings + 1, 0, 0, 0, 0, 0, false, false, false, false);
 }
 
-TEST_P(GLSLTest, MaxVaryingVec3ArrayAndMaxPlusOneFloatArray)
+// Disabled because drivers are allowed to successfully compile shaders that have more than the
+// maximum number of varyings. (http://anglebug.com/1296)
+TEST_P(GLSLTest, DISABLED_MaxVaryingVec3ArrayAndMaxPlusOneFloatArray)
 {
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
@@ -1253,6 +1330,13 @@ TEST_P(GLSLTest, VerifyMaxVertexUniformVectors)
 // can actually be used along with the maximum number of texture samplers.
 TEST_P(GLSLTest, VerifyMaxVertexUniformVectorsWithSamplers)
 {
+    if (GetParam().eglParameters.renderer == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE ||
+        GetParam().eglParameters.renderer == EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)
+    {
+        std::cout << "Test disabled on OpenGL." << std::endl;
+        return;
+    }
+
     int maxUniforms = 10000;
     glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &maxUniforms);
     EXPECT_GL_NO_ERROR();
@@ -1292,6 +1376,13 @@ TEST_P(GLSLTest, VerifyMaxFragmentUniformVectors)
 // can actually be used along with the maximum number of texture samplers.
 TEST_P(GLSLTest, VerifyMaxFragmentUniformVectorsWithSamplers)
 {
+    if (GetParam().eglParameters.renderer == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE ||
+        GetParam().eglParameters.renderer == EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)
+    {
+        std::cout << "Test disabled on OpenGL." << std::endl;
+        return;
+    }
+
     int maxUniforms = 10000;
     glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &maxUniforms);
     EXPECT_GL_NO_ERROR();
@@ -1316,7 +1407,14 @@ TEST_P(GLSLTest, VerifyMaxFragmentUniformVectorsExceeded)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(GLSLTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3());
+ANGLE_INSTANTIATE_TEST(GLSLTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(GLSLTest_ES3, ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(GLSLTest_ES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());

src/tests/gl_tests/ImageTest.cpp

@@ -1372,5 +1372,12 @@ TEST_P(ImageTest, UpdatedData)
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against.
-ANGLE_INSTANTIATE_TEST(ImageTest, ES2_D3D9(), ES2_D3D11(), ES3_D3D11(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(ImageTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 }

src/tests/gl_tests/IncompleteTextureTest.cpp

@@ -163,4 +163,8 @@ TEST_P(IncompleteTextureTest, UpdateTexture)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(IncompleteTextureTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(IncompleteTextureTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());

src/tests/gl_tests/IndexBufferOffsetTest.cpp

@@ -151,5 +151,6 @@ ANGLE_INSTANTIATE_TEST(IndexBufferOffsetTest,
                        ES2_D3D11(),
                        ES3_D3D11(),
                        ES2_OPENGL(),
-                       ES3_OPENGL());
-
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());

src/tests/gl_tests/IndexedPointsTest.cpp

@@ -386,6 +386,18 @@ TEST_P(IndexedPointsTestUInt, VertexWithColorUnsignedIntOffset3)
 }
 
 // TODO(geofflang): Figure out why this test fails on Intel OpenGL
-ANGLE_INSTANTIATE_TEST(IndexedPointsTestUByte, ES2_D3D11(), ES2_D3D11_FL9_3());
-ANGLE_INSTANTIATE_TEST(IndexedPointsTestUShort, ES2_D3D11(), ES2_D3D11_FL9_3());
-ANGLE_INSTANTIATE_TEST(IndexedPointsTestUInt, ES2_D3D11(), ES2_D3D11_FL9_3());
+ANGLE_INSTANTIATE_TEST(IndexedPointsTestUByte,
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(IndexedPointsTestUShort,
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(IndexedPointsTestUInt,
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());

src/tests/gl_tests/InstancingTest.cpp

@@ -320,7 +320,12 @@ TEST_P(InstancingTestNo9_3, DrawArraysWithOffset)
 
 // 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(), ES2_D3D11_FL9_3());
+ANGLE_INSTANTIATE_TEST(InstancingTestAllConfigs,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
 
 // TODO(jmadill): Figure out the situation with DrawInstanced on FL 9_3
 ANGLE_INSTANTIATE_TEST(InstancingTestNo9_3, ES2_D3D9(), ES2_D3D11());

src/tests/gl_tests/LineLoopTest.cpp

@@ -223,4 +223,4 @@ TEST_P(LineLoopTest, LineLoopUIntIndexBuffer)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(LineLoopTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(LineLoopTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES());

src/tests/gl_tests/MaxTextureSizeTest.cpp

@@ -291,5 +291,8 @@ TEST_P(MaxTextureSizeTest, RenderToTexture)
     glDeleteTextures(1, &textureId);
 }
 
+// TODO(geofflang): Fix the dependence on glBlitFramebufferANGLE without checks and assuming the
+// default framebuffer is BGRA to enable the GL and GLES backends. (http://anglebug.com/1289)
+
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 ANGLE_INSTANTIATE_TEST(MaxTextureSizeTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3());

src/tests/gl_tests/MipmapTest.cpp

@@ -915,16 +915,23 @@ TEST_P(MipmapTestES3, MipmapsForTexture3D)
     glUniform1f(mTexture3DLODUniformLocation, 1.);
     drawQuad(m3DProgram, "position", 0.5f);
     EXPECT_GL_NO_ERROR();
-    EXPECT_PIXEL_EQ(px, py, 127, 127, 0, 255);
+    EXPECT_PIXEL_NEAR(px, py, 127, 127, 0, 255, 1.0);
 
     glUseProgram(m3DProgram);
     glUniform1f(mTexture3DSliceUniformLocation, 0.75f);
     drawQuad(m3DProgram, "position", 0.5f);
     EXPECT_GL_NO_ERROR();
-    EXPECT_PIXEL_EQ(px, py, 127, 127, 0, 255);
+    EXPECT_PIXEL_NEAR(px, py, 127, 127, 0, 255, 1.0);
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 // Note: we run these tests against 9_3 on WARP due to hardware driver issues on Win7
-ANGLE_INSTANTIATE_TEST(MipmapTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3_WARP(), ES2_OPENGL(), ES3_OPENGL());
-ANGLE_INSTANTIATE_TEST(MipmapTestES3, ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(MipmapTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3_WARP(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(MipmapTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());

src/tests/gl_tests/OcclusionQueriesTest.cpp

@@ -365,4 +365,6 @@ ANGLE_INSTANTIATE_TEST(OcclusionQueriesTest,
                        ES2_D3D11(),
                        ES3_D3D11(),
                        ES2_OPENGL(),
-                       ES3_OPENGL());
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());

src/tests/gl_tests/PBOExtensionTest.cpp

@@ -150,4 +150,4 @@ TEST_P(PBOExtensionTest, PBOWithExistingData)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(PBOExtensionTest, ES2_D3D11(), ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(PBOExtensionTest, ES2_D3D11(), ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());

src/tests/gl_tests/PackUnpackTest.cpp

@@ -201,7 +201,13 @@ TEST_P(PackUnpackTest, PackUnpackSnormOverflow)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(PackUnpackTest, ES3_OPENGL(3, 3), ES3_OPENGL(4, 0), ES3_OPENGL(4, 1), ES3_OPENGL(4, 2),
-                                       ES3_OPENGL(4, 3), ES3_OPENGL(4, 4), ES3_OPENGL(4, 5));
-
+ANGLE_INSTANTIATE_TEST(PackUnpackTest,
+                       ES3_OPENGL(3, 3),
+                       ES3_OPENGL(4, 0),
+                       ES3_OPENGL(4, 1),
+                       ES3_OPENGL(4, 2),
+                       ES3_OPENGL(4, 3),
+                       ES3_OPENGL(4, 4),
+                       ES3_OPENGL(4, 5),
+                       ES3_OPENGLES());
 }

src/tests/gl_tests/PbufferTest.cpp

@@ -334,4 +334,10 @@ TEST_P(PbufferTest, BindTexImageAndRedefineTexture)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(PbufferTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES2_D3D11_WARP(), ES2_D3D11_REFERENCE());
+ANGLE_INSTANTIATE_TEST(PbufferTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_OPENGL(),
+                       ES2_D3D11_WARP(),
+                       ES2_D3D11_REFERENCE(),
+                       ES2_OPENGLES());

src/tests/gl_tests/PointSpritesTest.cpp

@@ -154,6 +154,7 @@ TEST_P(PointSpritesTest, PointCoordAndPointSizeCompliance)
 // https://www.khronos.org/registry/webgl/sdk/tests/conformance/rendering/point-no-attributes.html
 TEST_P(PointSpritesTest, PointWithoutAttributesCompliance)
 {
+    // clang-format off
     const std::string fs = SHADER_SOURCE
     (
         precision mediump float;
@@ -167,10 +168,11 @@ TEST_P(PointSpritesTest, PointWithoutAttributesCompliance)
     (
         void main()
         {
-            gl_PointSize = 1.0;
+            gl_PointSize = 2.0;
             gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
         }
     );
+    // clang-format on
 
     GLuint program = CompileProgram(vs, fs);
     ASSERT_NE(program, 0u);
@@ -438,4 +440,9 @@ TEST_P(PointSpritesTest, PointSizeDeclaredButUnused)
 // We test on D3D11 9_3 because the existing D3D11 PointSprite implementation
 // uses Geometry Shaders which are not supported for 9_3.
 // D3D9 and D3D11 are also tested to ensure no regressions.
-ANGLE_INSTANTIATE_TEST(PointSpritesTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3());
+ANGLE_INSTANTIATE_TEST(PointSpritesTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());

src/tests/gl_tests/ProvokingVertexTest.cpp

@@ -309,6 +309,6 @@ TEST_P(ProvokingVertexTest, FlatTriStripPrimitiveRestart)
     }
 }
 
-ANGLE_INSTANTIATE_TEST(ProvokingVertexTest, ES3_D3D11(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(ProvokingVertexTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
 
 }  // anonymous namespace

src/tests/gl_tests/ReadPixelsTest.cpp

@@ -151,6 +151,13 @@ TEST_P(ReadPixelsTest, PBOWithOtherTarget)
 
 TEST_P(ReadPixelsTest, PBOWithExistingData)
 {
+    // TODO(geofflang): Figure out why this fails on AMD OpenGL (http://anglebug.com/1291)
+    if (isAMD() && getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE)
+    {
+        std::cout << "Test disabled on AMD OpenGL." << std::endl;
+        return;
+    }
+
     // Clear backbuffer to red
     glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT);
@@ -345,4 +352,4 @@ TEST_P(ReadPixelsTest, MultisampledPBO)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(ReadPixelsTest, ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(ReadPixelsTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());

src/tests/gl_tests/RendererTest.cpp

@@ -127,13 +127,84 @@ TEST_P(RendererTest, SimpleOperation)
 // Select configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 
 ANGLE_INSTANTIATE_TEST(RendererTest,
-    ES2_D3D9(),            ES2_D3D9_REFERENCE(),
-    ES2_D3D11(),           ES2_D3D11_FL11_0(),           ES2_D3D11_FL10_1(),           ES2_D3D11_FL10_0(),           ES2_D3D11_FL9_3(),
-    ES2_D3D11_WARP(),      ES2_D3D11_FL11_0_WARP(),      ES2_D3D11_FL10_1_WARP(),      ES2_D3D11_FL10_0_WARP(),      ES2_D3D11_FL9_3_WARP(),
-    ES2_D3D11_REFERENCE(), ES2_D3D11_FL11_0_REFERENCE(), ES2_D3D11_FL10_1_REFERENCE(), ES2_D3D11_FL10_0_REFERENCE(), ES2_D3D11_FL9_3_REFERENCE(),
-    ES3_D3D11(),           ES3_D3D11_FL11_0(),           ES3_D3D11_FL10_1(),           ES3_D3D11_FL10_0(),
-    ES3_D3D11_WARP(),      ES3_D3D11_FL11_0_WARP(),      ES3_D3D11_FL10_1_WARP(),      ES3_D3D11_FL10_0_WARP(),
-    ES3_D3D11_REFERENCE(), ES3_D3D11_FL11_0_REFERENCE(), ES3_D3D11_FL10_1_REFERENCE(), ES3_D3D11_FL10_0_REFERENCE(),
-    ES2_OPENGL(),          ES3_OPENGL());
-
+                       // ES2 on top of D3D9
+                       ES2_D3D9(),
+                       ES2_D3D9_REFERENCE(),
+
+                       // ES2 on top of D3D11 feature level 9.3 to 11.0
+                       ES2_D3D11(),
+                       ES2_D3D11_FL11_0(),
+                       ES2_D3D11_FL10_1(),
+                       ES2_D3D11_FL10_0(),
+                       ES2_D3D11_FL9_3(),
+
+                       // ES2 on top of D3D11 WARP feature level 9.3 to 11.0
+                       ES2_D3D11_WARP(),
+                       ES2_D3D11_FL11_0_WARP(),
+                       ES2_D3D11_FL10_1_WARP(),
+                       ES2_D3D11_FL10_0_WARP(),
+                       ES2_D3D11_FL9_3_WARP(),
+
+                       // ES2 on top of D3D11 reference feature level 9.3 to 11.0
+                       ES2_D3D11_REFERENCE(),
+                       ES2_D3D11_FL11_0_REFERENCE(),
+                       ES2_D3D11_FL10_1_REFERENCE(),
+                       ES2_D3D11_FL10_0_REFERENCE(),
+                       ES2_D3D11_FL9_3_REFERENCE(),
+
+                       // ES3 on top of D3D11 feature level 9.3 to 11.0
+                       ES3_D3D11(),
+                       ES3_D3D11_FL11_0(),
+                       ES3_D3D11_FL10_1(),
+                       ES3_D3D11_FL10_0(),
+
+                       // ES3 on top of D3D11 WARP feature level 9.3 to 11.0
+                       ES3_D3D11_WARP(),
+                       ES3_D3D11_FL11_0_WARP(),
+                       ES3_D3D11_FL10_1_WARP(),
+                       ES3_D3D11_FL10_0_WARP(),
+
+                       // ES3 on top of D3D11 reference feature level 9.3 to 11.0
+                       ES3_D3D11_REFERENCE(),
+                       ES3_D3D11_FL11_0_REFERENCE(),
+                       ES3_D3D11_FL10_1_REFERENCE(),
+                       ES3_D3D11_FL10_0_REFERENCE(),
+
+                       // ES2 on top of desktop OpenGL versions 2.1 to 4.5
+                       ES2_OPENGL(),
+                       ES2_OPENGL(2, 1),
+                       ES2_OPENGL(3, 0),
+                       ES2_OPENGL(3, 1),
+                       ES2_OPENGL(3, 2),
+                       ES2_OPENGL(3, 3),
+                       ES2_OPENGL(4, 0),
+                       ES2_OPENGL(4, 1),
+                       ES2_OPENGL(4, 2),
+                       ES2_OPENGL(4, 3),
+                       ES2_OPENGL(4, 4),
+                       ES2_OPENGL(4, 5),
+
+                       // ES2 on top of desktop OpenGL versions 3.2 to 4.5
+                       ES3_OPENGL(),
+                       ES3_OPENGL(3, 2),
+                       ES3_OPENGL(3, 3),
+                       ES3_OPENGL(4, 0),
+                       ES3_OPENGL(4, 1),
+                       ES3_OPENGL(4, 2),
+                       ES3_OPENGL(4, 3),
+                       ES3_OPENGL(4, 4),
+                       ES3_OPENGL(4, 5),
+
+                       // ES2 on top of OpenGL ES 2.0 to 3.2
+                       ES2_OPENGLES(),
+                       ES2_OPENGLES(2, 0),
+                       ES2_OPENGLES(3, 0),
+                       ES2_OPENGLES(3, 1),
+                       ES2_OPENGLES(3, 2),
+
+                       // ES2 on top of OpenGL ES 3.0 to 3.2
+                       ES3_OPENGLES(),
+                       ES3_OPENGLES(3, 0),
+                       ES3_OPENGLES(3, 1),
+                       ES3_OPENGLES(3, 2));
 }

src/tests/gl_tests/SRGBTextureTest.cpp

@@ -144,6 +144,11 @@ TEST_P(SRGBTextureTest, SRGBARenderbuffer)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(SRGBTextureTest, ES2_D3D9(), ES2_D3D11(), ES3_D3D11(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(SRGBTextureTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
 
 } // namespace

src/tests/gl_tests/SimpleOperationTest.cpp

@@ -199,8 +199,13 @@ TEST_P(SimpleOperationTest, BufferSubData)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(
-    SimpleOperationTest,
-    ES2_D3D9(), ES2_D3D11(), ES3_D3D11(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(SimpleOperationTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 
 } // namespace

src/tests/gl_tests/SixteenBppTextureTest.cpp

@@ -298,6 +298,11 @@ TEST_P(SixteenBppTextureTest, RGBA4444Validation)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(SixteenBppTextureTest, ES2_D3D9(),  ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(SixteenBppTextureTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
 
 } // namespace

src/tests/gl_tests/SwizzleTest.cpp

@@ -340,6 +340,6 @@ TEST_P(SwizzleTest, CompressedDXT_2D)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(SwizzleTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGL(3, 3));
+ANGLE_INSTANTIATE_TEST(SwizzleTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGL(3, 3), ES3_OPENGLES());
 
 } // namespace

src/tests/gl_tests/TextureTest.cpp

@@ -1220,6 +1220,15 @@ TEST_P(Texture2DTest, TextureNPOT_GL_ALPHA_UBYTE)
 // ANGLE previously rejected this if GL_OES_texture_npot wasn't active, which is incorrect.
 TEST_P(Texture2DTest, NPOTSubImageParameters)
 {
+    // TODO(geofflang): Allow the GL backend to accept SubImage calls with a null data ptr. (bug
+    // 1278)
+    if (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE ||
+        getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE)
+    {
+        std::cout << "Test disabled on OpenGL." << std::endl;
+        return;
+    }
+
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, mTexture2D);
 
@@ -1808,24 +1817,49 @@ TEST_P(TextureLimitsTest, DrawWithTexturePastMaximum)
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 // TODO(oetuaho): Enable all below tests on OpenGL. Requires a fix for ANGLE bug 1278.
-ANGLE_INSTANTIATE_TEST(Texture2DTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3());
-ANGLE_INSTANTIATE_TEST(TextureCubeTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL());
+ANGLE_INSTANTIATE_TEST(Texture2DTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(TextureCubeTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
 ANGLE_INSTANTIATE_TEST(Texture2DTestWithDrawScale,
                        ES2_D3D9(),
                        ES2_D3D11(),
                        ES2_D3D11_FL9_3(),
-                       ES2_OPENGL());
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
 ANGLE_INSTANTIATE_TEST(Sampler2DAsFunctionParameterTest,
                        ES2_D3D9(),
                        ES2_D3D11(),
                        ES2_D3D11_FL9_3(),
-                       ES2_OPENGL());
-ANGLE_INSTANTIATE_TEST(SamplerArrayTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL());
-ANGLE_INSTANTIATE_TEST(SamplerArrayAsFunctionParameterTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3());
-ANGLE_INSTANTIATE_TEST(Texture2DTestES3, ES3_D3D11(), ES3_OPENGL());
-ANGLE_INSTANTIATE_TEST(ShadowSamplerPlusSampler3DTestES3, ES3_D3D11(), ES3_OPENGL());
-ANGLE_INSTANTIATE_TEST(SamplerTypeMixTestES3, ES3_D3D11(), ES3_OPENGL());
-ANGLE_INSTANTIATE_TEST(Texture2DArrayTestES3, ES3_D3D11(), ES3_OPENGL());
-ANGLE_INSTANTIATE_TEST(TextureLimitsTest, ES2_D3D11(), ES2_OPENGL());
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(SamplerArrayTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(SamplerArrayAsFunctionParameterTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(Texture2DTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(ShadowSamplerPlusSampler3DTestES3,
+                       ES3_D3D11(),
+                       ES3_OPENGL(),
+                       ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(SamplerTypeMixTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(Texture2DArrayTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
+ANGLE_INSTANTIATE_TEST(TextureLimitsTest, ES2_D3D11(), ES2_OPENGL(), ES2_OPENGLES());
 
 } // namespace

src/tests/gl_tests/TransformFeedbackTest.cpp

@@ -700,6 +700,6 @@ TEST_P(TransformFeedbackTest, PackingBug)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(TransformFeedbackTest, ES3_D3D11(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(TransformFeedbackTest, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
 
 }  // anonymous namespace

src/tests/gl_tests/UniformBufferTest.cpp

@@ -246,7 +246,8 @@ TEST_P(UniformBufferTest, UnboundUniformBuffer)
 TEST_P(UniformBufferTest, UniformBufferManyUpdates)
 {
     // TODO(jmadill): Figure out why this fails on Intel.
-    if (isIntel() && GetParam().getRenderer() == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+    if (isIntel() && (getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE ||
+                      getPlatformRenderer() == EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE))
     {
         std::cout << "Test skipped on Intel." << std::endl;
         return;
@@ -412,6 +413,11 @@ TEST_P(UniformBufferTest, ActiveUniformNames)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(UniformBufferTest, ES3_D3D11(), ES3_D3D11_FL11_1(), ES3_D3D11_FL11_1_REFERENCE());
+ANGLE_INSTANTIATE_TEST(UniformBufferTest,
+                       ES3_D3D11(),
+                       ES3_D3D11_FL11_1(),
+                       ES3_D3D11_FL11_1_REFERENCE(),
+                       ES3_OPENGL(),
+                       ES3_OPENGLES());
 
 } // namespace

src/tests/gl_tests/UniformTest.cpp

@@ -501,7 +501,12 @@ TEST_P(UniformTest, SamplerUniformsAppearOnce)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(UniformTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL());
-ANGLE_INSTANTIATE_TEST(UniformTestES3, ES3_D3D11(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(UniformTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES2_OPENGLES());
+ANGLE_INSTANTIATE_TEST(UniformTestES3, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
 
 } // namespace

src/tests/gl_tests/UnpackAlignmentTest.cpp

@@ -314,6 +314,12 @@ TEST_P(UnpackAlignmentTest, Alignment8AUByte)
 }
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(UnpackAlignmentTest, ES2_D3D9(), ES2_D3D11(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(UnpackAlignmentTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 
 } // namespace

src/tests/gl_tests/UnpackRowLength.cpp

@@ -123,6 +123,8 @@ ANGLE_INSTANTIATE_TEST(UnpackRowLengthTest,
                        ES2_D3D11(),
                        ES2_D3D9(),
                        ES2_OPENGL(),
-                       ES3_OPENGL());
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 
 } // namespace

src/tests/gl_tests/VertexAttributeTest.cpp

@@ -358,6 +358,13 @@ TEST_P(VertexAttributeTest, SimpleBindAttribLocation)
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 // D3D11 Feature Level 9_3 uses different D3D formats for vertex attribs compared to Feature Levels 10_0+, so we should test them separately.
-ANGLE_INSTANTIATE_TEST(VertexAttributeTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL(), ES3_OPENGL());
+ANGLE_INSTANTIATE_TEST(VertexAttributeTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 
 } // namespace

src/tests/gl_tests/ViewportTest.cpp

@@ -261,6 +261,11 @@ TEST_P(ViewportTest, TripleWindowOffCenter)
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 // D3D11 Feature Level 9 and D3D9 emulate large and negative viewports in the vertex shader. We should test both of these as well as D3D11 Feature Level 10_0+.
-ANGLE_INSTANTIATE_TEST(ViewportTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3());
+ANGLE_INSTANTIATE_TEST(ViewportTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES2_D3D11_FL9_3(),
+                       ES2_OPENGLES(),
+                       ES3_OPENGLES());
 
 } // namespace

src/tests/test_utils/angle_test_configs.cpp

@@ -69,7 +69,7 @@ std::ostream &operator<<(std::ostream& stream, const PlatformParameters &pp)
         stream << "OPENGL";
         break;
       case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
-        stream << "GLES";
+          stream << "OPENGLES";
         break;
       case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
         stream << "DEFAULT";
@@ -336,6 +336,12 @@ EGLPlatformParameters OPENGLES()
     return EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE);
 }
 
+EGLPlatformParameters OPENGLES(EGLint major, EGLint minor)
+{
+    return EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE, major, minor,
+                                 EGL_DONT_CARE);
+}
+
 } // namespace egl_platform
 
 // ANGLE tests platforms
@@ -504,11 +510,21 @@ PlatformParameters ES2_OPENGLES()
     return PlatformParameters(2, 0, egl_platform::OPENGLES());
 }
 
+PlatformParameters ES2_OPENGLES(EGLint major, EGLint minor)
+{
+    return PlatformParameters(2, 0, egl_platform::OPENGLES(major, minor));
+}
+
 PlatformParameters ES3_OPENGLES()
 {
     return PlatformParameters(3, 0, egl_platform::OPENGLES());
 }
 
+PlatformParameters ES3_OPENGLES(EGLint major, EGLint minor)
+{
+    return PlatformParameters(3, 0, egl_platform::OPENGLES(major, minor));
+}
+
 PlatformParameters ES2_OPENGL()
 {
     return PlatformParameters(2, 0, egl_platform::OPENGL());

src/tests/test_utils/angle_test_configs.h

@@ -79,6 +79,7 @@ EGLPlatformParameters OPENGL(EGLint major, EGLint minor);
 EGLPlatformParameters OPENGL_NULL();
 
 EGLPlatformParameters OPENGLES();
+EGLPlatformParameters OPENGLES(EGLint major, EGLint minor);
 
 } // namespace egl_platform
 
@@ -128,7 +129,9 @@ PlatformParameters ES3_OPENGL();
 PlatformParameters ES3_OPENGL(EGLint major, EGLint minor);
 
 PlatformParameters ES2_OPENGLES();
+PlatformParameters ES2_OPENGLES(EGLint major, EGLint minor);
 PlatformParameters ES3_OPENGLES();
+PlatformParameters ES3_OPENGLES(EGLint major, EGLint minor);
 
 } // namespace angle