Add some shared utilities for multiview tests

src/tests/angle_end2end_tests.gypi

@@ -141,6 +141,8 @@
             '<(angle_path)/src/tests/egl_tests/EGLThreadTest.cpp',
             '<(angle_path)/src/tests/test_utils/ANGLETest.cpp',
             '<(angle_path)/src/tests/test_utils/ANGLETest.h',
+            '<(angle_path)/src/tests/test_utils/MultiviewTest.cpp',
+            '<(angle_path)/src/tests/test_utils/MultiviewTest.h',
             '<(angle_path)/src/tests/test_utils/angle_test_configs.cpp',
             '<(angle_path)/src/tests/test_utils/angle_test_configs.h',
             '<(angle_path)/src/tests/test_utils/angle_test_instantiate.cpp',

src/tests/gl_tests/FramebufferMultiviewTest.cpp

@@ -7,7 +7,7 @@
 // The tests modify and examine the multiview state.
 //
 
-#include "test_utils/ANGLETest.h"
+#include "test_utils/MultiviewTest.h"
 #include "test_utils/gl_raii.h"
 
 using namespace angle;
@@ -26,39 +26,11 @@ std::vector<GLenum> GetDrawBufferRange(size_t numColorAttachments)
 }
 }  // namespace
 
-class FramebufferMultiviewTest : public ANGLETest
+// Base class for tests that care mostly about draw call validity and not rendering results.
+class FramebufferMultiviewTest : public MultiviewTest
 {
   protected:
-    FramebufferMultiviewTest()
-    {
-        setWindowWidth(128);
-        setWindowHeight(128);
-        setWebGLCompatibilityEnabled(true);
-    }
-
-    void SetUp() override
-    {
-        ANGLETest::SetUp();
-        glRequestExtensionANGLE = reinterpret_cast<PFNGLREQUESTEXTENSIONANGLEPROC>(
-            eglGetProcAddress("glRequestExtensionANGLE"));
-    }
-
-    // Requests the ANGLE_multiview extension and returns true if the operation succeeds.
-    bool requestMultiviewExtension()
-    {
-        if (extensionRequestable("GL_ANGLE_multiview"))
-        {
-            glRequestExtensionANGLE("GL_ANGLE_multiview");
-        }
-
-        if (!extensionEnabled("GL_ANGLE_multiview"))
-        {
-            return false;
-        }
-        return true;
-    }
-
-    PFNGLREQUESTEXTENSIONANGLEPROC glRequestExtensionANGLE = nullptr;
+    FramebufferMultiviewTest() : MultiviewTest() {}
 };
 
 class FramebufferMultiviewSideBySideClearTest : public FramebufferMultiviewTest
@@ -1398,6 +1370,10 @@ TEST_P(FramebufferMultiviewLayeredClearTest, ColorBufferClearAllLayersAttached)
     EXPECT_EQ(GLColor::green, getLayerColor(1, GL_COLOR_ATTACHMENT0));
 }
 
-ANGLE_INSTANTIATE_TEST(FramebufferMultiviewTest, ES3_OPENGL(), ES3_D3D11());
-ANGLE_INSTANTIATE_TEST(FramebufferMultiviewSideBySideClearTest, ES3_OPENGL(), ES3_D3D11());
-ANGLE_INSTANTIATE_TEST(FramebufferMultiviewLayeredClearTest, ES3_OPENGL(), ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(FramebufferMultiviewTest, VertexShaderOpenGL(3, 0), GeomShaderD3D11(3, 0));
+ANGLE_INSTANTIATE_TEST(FramebufferMultiviewSideBySideClearTest,
+                       VertexShaderOpenGL(3, 0),
\ No newline at end of file
+                       GeomShaderD3D11(3, 0));
+ANGLE_INSTANTIATE_TEST(FramebufferMultiviewLayeredClearTest,
+                       VertexShaderOpenGL(3, 0),
+                       GeomShaderD3D11(3, 0));
\ No newline at end of file

src/tests/gl_tests/MultiviewDrawTest.cpp

@@ -8,39 +8,13 @@
 //
 
 #include "platform/WorkaroundsD3D.h"
-#include "test_utils/ANGLETest.h"
+#include "test_utils/MultiviewTest.h"
 #include "test_utils/gl_raii.h"
 
 using namespace angle;
 
 namespace
 {
-GLuint CreateSimplePassthroughProgram(int numViews)
-{
-    const std::string vsSource =
-        "#version 300 es\n"
-        "#extension GL_OVR_multiview : require\n"
-        "layout(num_views = " +
-        ToString(numViews) +
-        ") in;\n"
-        "layout(location=0) in vec2 vPosition;\n"
-        "void main()\n"
-        "{\n"
-        "   gl_PointSize = 1.;\n"
-        "   gl_Position = vec4(vPosition.xy, 0.0, 1.0);\n"
-        "}\n";
-
-    const std::string fsSource =
-        "#version 300 es\n"
-        "#extension GL_OVR_multiview : require\n"
-        "precision mediump float;\n"
-        "out vec4 col;\n"
-        "void main()\n"
-        "{\n"
-        "   col = vec4(0,1,0,1);\n"
-        "}\n";
-    return CompileProgram(vsSource, fsSource);
-}
 
 std::vector<Vector2> ConvertPixelCoordinatesToClipSpace(const std::vector<Vector2I> &pixels,
                                                         int width,
@@ -60,38 +34,10 @@ std::vector<Vector2> ConvertPixelCoordinatesToClipSpace(const std::vector<Vector
 }
 }  // namespace
 
-struct MultiviewImplementationParams : public PlatformParameters
-{
-    MultiviewImplementationParams(GLint majorVersion,
-                                  GLint minorVersion,
-                                  bool forceUseGeometryShaderOnD3D,
-                                  const EGLPlatformParameters &eglPlatformParameters)
-        : PlatformParameters(majorVersion, minorVersion, eglPlatformParameters),
-          mForceUseGeometryShaderOnD3D(forceUseGeometryShaderOnD3D)
-    {
-    }
-    bool mForceUseGeometryShaderOnD3D;
-};
-
-std::ostream &operator<<(std::ostream &os, const MultiviewImplementationParams &params)
-{
-    const PlatformParameters &base = static_cast<const PlatformParameters &>(params);
-    os << base;
-    if (params.mForceUseGeometryShaderOnD3D)
-    {
-        os << "_force_geom_shader";
-    }
-    else
-    {
-        os << "_vertex_shader";
-    }
-    return os;
-}
-
-struct MultiviewTestParams final : public MultiviewImplementationParams
+struct MultiviewRenderTestParams final : public MultiviewImplementationParams
 {
-    MultiviewTestParams(GLenum multiviewLayout,
-                        const MultiviewImplementationParams &implementationParams)
+    MultiviewRenderTestParams(GLenum multiviewLayout,
+                              const MultiviewImplementationParams &implementationParams)
         : MultiviewImplementationParams(implementationParams), mMultiviewLayout(multiviewLayout)
     {
         ASSERT(multiviewLayout == GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE ||
@@ -100,7 +46,7 @@ struct MultiviewTestParams final : public MultiviewImplementationParams
     GLenum mMultiviewLayout;
 };
 
-std::ostream &operator<<(std::ostream &os, const MultiviewTestParams &params)
+std::ostream &operator<<(std::ostream &os, const MultiviewRenderTestParams &params)
 {
     const MultiviewImplementationParams &base =
         static_cast<const MultiviewImplementationParams &>(params);
@@ -119,56 +65,18 @@ std::ostream &operator<<(std::ostream &os, const MultiviewTestParams &params)
     return os;
 }
 
-class MultiviewDrawTest : public ANGLETestBase
-{
-  protected:
-    MultiviewDrawTest(const PlatformParameters &params) : ANGLETestBase(params)
-    {
-        setWindowWidth(128);
-        setWindowHeight(128);
-        setWebGLCompatibilityEnabled(true);
-    }
-    virtual ~MultiviewDrawTest() {}
-
-    void DrawTestSetUp()
-    {
-        ANGLETestBase::ANGLETestSetUp();
-
-        glRequestExtensionANGLE = reinterpret_cast<PFNGLREQUESTEXTENSIONANGLEPROC>(
-            eglGetProcAddress("glRequestExtensionANGLE"));
-    }
-
-    // Requests the ANGLE_multiview extension and returns true if the operation succeeds.
-    bool requestMultiviewExtension()
-    {
-        if (extensionRequestable("GL_ANGLE_multiview"))
-        {
-            glRequestExtensionANGLE("GL_ANGLE_multiview");
-        }
-
-        if (!extensionEnabled("GL_ANGLE_multiview"))
-        {
-            std::cout << "Test skipped due to missing GL_ANGLE_multiview." << std::endl;
-            return false;
-        }
-        return true;
-    }
-
-    PFNGLREQUESTEXTENSIONANGLEPROC glRequestExtensionANGLE = nullptr;
-};
-
-class MultiviewRenderTestBase : public MultiviewDrawTest
+class MultiviewRenderTestBase : public MultiviewTestBase
 {
   protected:
     MultiviewRenderTestBase(const PlatformParameters &params, GLenum multiviewLayout)
-        : MultiviewDrawTest(params),
+        : MultiviewTestBase(params),
           mMultiviewLayout(multiviewLayout),
           mViewWidth(0),
           mViewHeight(0),
           mNumViews(0)
     {
     }
-    void RenderTestSetUp() { MultiviewDrawTest::DrawTestSetUp(); }
+    void RenderTestSetUp() { MultiviewTestBase::MultiviewTestBaseSetUp(); }
     void createFBO(int viewWidth, int height, int numViews, int numLayers, int baseViewIndex)
     {
         ASSERT(numViews + baseViewIndex <= numLayers);
@@ -328,7 +236,7 @@ class MultiviewRenderTestBase : public MultiviewDrawTest
 };
 
 class MultiviewRenderTest : public MultiviewRenderTestBase,
-                            public ::testing::TestWithParam<MultiviewTestParams>
+                            public ::testing::TestWithParam<MultiviewRenderTestParams>
 {
   protected:
     MultiviewRenderTest() : MultiviewRenderTestBase(GetParam(), GetParam().mMultiviewLayout) {}
@@ -2225,51 +2133,41 @@ TEST_P(MultiviewSideBySideRenderTest, ViewportOffsetsAppliedBugCoverage)
     EXPECT_EQ(GLColor::green, GetViewColor(0, 0, 1));
 }
 
-MultiviewImplementationParams VertexShaderOpenGL(GLint majorVersion, GLint minorVersion)
-{
-    return MultiviewImplementationParams(majorVersion, minorVersion, false, egl_platform::OPENGL());
-}
-
-MultiviewImplementationParams VertexShaderD3D11(GLint majorVersion, GLint minorVersion)
-{
-    return MultiviewImplementationParams(majorVersion, minorVersion, false, egl_platform::D3D11());
-}
-
-MultiviewImplementationParams GeomShaderD3D11(GLint majorVersion, GLint minorVersion)
-{
-    return MultiviewImplementationParams(majorVersion, minorVersion, true, egl_platform::D3D11());
-}
-
-MultiviewTestParams SideBySideVertexShaderOpenGL(GLint majorVersion = 3, GLint minorVersion = 0)
+MultiviewRenderTestParams SideBySideVertexShaderOpenGL(GLint majorVersion = 3,
+                                                       GLint minorVersion = 0)
 {
-    return MultiviewTestParams(GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE,
-                               VertexShaderOpenGL(majorVersion, minorVersion));
+    return MultiviewRenderTestParams(GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE,
+                                     VertexShaderOpenGL(majorVersion, minorVersion));
 }
 
-MultiviewTestParams LayeredVertexShaderOpenGL()
+MultiviewRenderTestParams LayeredVertexShaderOpenGL()
 {
-    return MultiviewTestParams(GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE, VertexShaderOpenGL(3, 0));
+    return MultiviewRenderTestParams(GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE,
+                                     VertexShaderOpenGL(3, 0));
 }
 
-MultiviewTestParams SideBySideGeomShaderD3D11()
+MultiviewRenderTestParams SideBySideGeomShaderD3D11()
 {
-    return MultiviewTestParams(GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE, GeomShaderD3D11(3, 0));
+    return MultiviewRenderTestParams(GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE,
+                                     GeomShaderD3D11(3, 0));
 }
 
-MultiviewTestParams LayeredGeomShaderD3D11()
+MultiviewRenderTestParams LayeredGeomShaderD3D11()
 {
-    return MultiviewTestParams(GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE, GeomShaderD3D11(3, 0));
+    return MultiviewRenderTestParams(GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE, GeomShaderD3D11(3, 0));
 }
 
-MultiviewTestParams SideBySideVertexShaderD3D11(GLint majorVersion = 3, GLint minorVersion = 0)
+MultiviewRenderTestParams SideBySideVertexShaderD3D11(GLint majorVersion = 3,
+                                                      GLint minorVersion = 0)
 {
-    return MultiviewTestParams(GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE,
-                               VertexShaderD3D11(majorVersion, minorVersion));
+    return MultiviewRenderTestParams(GL_FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE,
+                                     VertexShaderD3D11(majorVersion, minorVersion));
 }
 
-MultiviewTestParams LayeredVertexShaderD3D11()
+MultiviewRenderTestParams LayeredVertexShaderD3D11()
 {
-    return MultiviewTestParams(GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE, VertexShaderD3D11(3, 0));
+    return MultiviewRenderTestParams(GL_FRAMEBUFFER_MULTIVIEW_LAYERED_ANGLE,
+                                     VertexShaderD3D11(3, 0));
 }
 
 ANGLE_INSTANTIATE_TEST(MultiviewDrawValidationTest,

src/tests/test_utils/MultiviewTest.cpp

+//
+// Copyright 2018 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// MultiviewTest:
+//   Implementation of helpers for multiview testing.
+//
+
+#include "test_utils/MultiviewTest.h"
+#include "platform/WorkaroundsD3D.h"
+
+namespace angle
+{
+
+GLuint CreateSimplePassthroughProgram(int numViews)
+{
+    const std::string vsSource =
+        "#version 300 es\n"
+        "#extension GL_OVR_multiview : require\n"
+        "layout(num_views = " +
+        ToString(numViews) +
+        ") in;\n"
+        "layout(location=0) in vec2 vPosition;\n"
+        "void main()\n"
+        "{\n"
+        "   gl_PointSize = 1.;\n"
+        "   gl_Position = vec4(vPosition.xy, 0.0, 1.0);\n"
+        "}\n";
+
+    const std::string fsSource =
+        "#version 300 es\n"
+        "#extension GL_OVR_multiview : require\n"
+        "precision mediump float;\n"
+        "out vec4 col;\n"
+        "void main()\n"
+        "{\n"
+        "   col = vec4(0,1,0,1);\n"
+        "}\n";
+    return CompileProgram(vsSource, fsSource);
+}
+
+std::ostream &operator<<(std::ostream &os, const MultiviewImplementationParams &params)
+{
+    const PlatformParameters &base = static_cast<const PlatformParameters &>(params);
+    os << base;
+    if (params.mForceUseGeometryShaderOnD3D)
+    {
+        os << "_force_geom_shader";
+    }
+    else
+    {
+        os << "_vertex_shader";
+    }
+    return os;
+}
+
+MultiviewImplementationParams VertexShaderOpenGL(GLint majorVersion, GLint minorVersion)
+{
+    return MultiviewImplementationParams(majorVersion, minorVersion, false, egl_platform::OPENGL());
+}
+
+MultiviewImplementationParams VertexShaderD3D11(GLint majorVersion, GLint minorVersion)
+{
+    return MultiviewImplementationParams(majorVersion, minorVersion, false, egl_platform::D3D11());
+}
+
+MultiviewImplementationParams GeomShaderD3D11(GLint majorVersion, GLint minorVersion)
+{
+    return MultiviewImplementationParams(majorVersion, minorVersion, true, egl_platform::D3D11());
+}
+
+void MultiviewTest::overrideWorkaroundsD3D(WorkaroundsD3D *workarounds)
+{
+    workarounds->selectViewInGeometryShader = GetParam().mForceUseGeometryShaderOnD3D;
+}
+
+}  // namespace angle

src/tests/test_utils/MultiviewTest.h

+//
+// Copyright 2018 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// MultiviewTest:
+//   Implementation of helpers for multiview testing.
+//
+
+#ifndef ANGLE_TESTS_TESTUTILS_MULTIVIEWTEST_H_
+#define ANGLE_TESTS_TESTUTILS_MULTIVIEWTEST_H_
+
+#include "test_utils/ANGLETest.h"
+
+namespace angle
+{
+
+// Creates a simple program that passes through two-dimensional vertices and renders green
+// fragments.
+GLuint CreateSimplePassthroughProgram(int numViews);
+
+struct MultiviewImplementationParams : public PlatformParameters
+{
+    MultiviewImplementationParams(GLint majorVersion,
+                                  GLint minorVersion,
+                                  bool forceUseGeometryShaderOnD3D,
+                                  const EGLPlatformParameters &eglPlatformParameters)
+        : PlatformParameters(majorVersion, minorVersion, eglPlatformParameters),
+          mForceUseGeometryShaderOnD3D(forceUseGeometryShaderOnD3D)
+    {
+    }
+    bool mForceUseGeometryShaderOnD3D;
+};
+std::ostream &operator<<(std::ostream &os, const MultiviewImplementationParams &params);
+
+MultiviewImplementationParams VertexShaderOpenGL(GLint majorVersion, GLint minorVersion);
+MultiviewImplementationParams VertexShaderD3D11(GLint majorVersion, GLint minorVersion);
+MultiviewImplementationParams GeomShaderD3D11(GLint majorVersion, GLint minorVersion);
+
+class MultiviewTestBase : public ANGLETestBase
+{
+  protected:
+    MultiviewTestBase(const PlatformParameters &params) : ANGLETestBase(params)
+    {
+        setWindowWidth(128);
+        setWindowHeight(128);
+        setWebGLCompatibilityEnabled(true);
+    }
+    virtual ~MultiviewTestBase() {}
+
+    void MultiviewTestBaseSetUp()
+    {
+        ANGLETestBase::ANGLETestSetUp();
+
+        glRequestExtensionANGLE = reinterpret_cast<PFNGLREQUESTEXTENSIONANGLEPROC>(
+            eglGetProcAddress("glRequestExtensionANGLE"));
+    }
+
+    void MultiviewTestBaseTearDown() { ANGLETestBase::ANGLETestTearDown(); }
+
+    // Requests the ANGLE_multiview extension and returns true if the operation succeeds.
+    bool requestMultiviewExtension()
+    {
+        if (extensionRequestable("GL_ANGLE_multiview"))
+        {
+            glRequestExtensionANGLE("GL_ANGLE_multiview");
+        }
+
+        if (!extensionEnabled("GL_ANGLE_multiview"))
+        {
+            std::cout << "Test skipped due to missing GL_ANGLE_multiview." << std::endl;
+            return false;
+        }
+        return true;
+    }
+
+    PFNGLREQUESTEXTENSIONANGLEPROC glRequestExtensionANGLE = nullptr;
+};
+
+// Base class for multiview tests that don't need specific helper functions.
+class MultiviewTest : public MultiviewTestBase,
+                      public ::testing::TestWithParam<MultiviewImplementationParams>
+{
+  protected:
+    MultiviewTest() : MultiviewTestBase(GetParam()) {}
+    void SetUp() override { MultiviewTestBase::MultiviewTestBaseSetUp(); }
+    void TearDown() override { MultiviewTestBase::MultiviewTestBaseTearDown(); }
+
+    void overrideWorkaroundsD3D(WorkaroundsD3D *workarounds) final;
+};
+
+}  // namespace angle
+
+#endif  // ANGLE_TESTS_TESTUTILS_MULTIVIEWTEST_H_