Make perftests use ANGLE_INSTANTIATE_TEST

src/tests/angle_end2end_tests.gypi

@@ -54,6 +54,7 @@
             '<(angle_path)/src/tests/test_utils/ANGLETest.cpp',
             '<(angle_path)/src/tests/test_utils/ANGLETest.h',
             '<(angle_path)/src/tests/test_utils/angle_test_configs.h',
+            '<(angle_path)/src/tests/test_utils/angle_test_instantiate.h',
         ],
         'angle_end2end_tests_win_sources':
         [

src/tests/angle_perftests.gypi

@@ -24,6 +24,7 @@
             'perf_tests/TexSubImage.cpp',
             'perf_tests/third_party/perf/perf_test.cc',
             'perf_tests/third_party/perf/perf_test.h',
+            'test_utils/angle_test_instantiate.h',
         ],
         'angle_perf_tests_win_sources':
         [
@@ -47,6 +48,10 @@
     [
         '<@(angle_perf_tests_sources)',
     ],
+    'include_dirs':
+    [
+        '<(angle_path)/src/tests'
+    ],
     'conditions':
     [
         ['OS=="win"',

src/tests/perf_tests/ANGLEPerfTest.cpp

@@ -74,10 +74,18 @@ std::string RenderTestParams::suffix() const
     {
         case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE: return "_d3d11";
         case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE: return "_d3d9";
+        case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE: return "_gl";
+        case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE: return "_gles";
+        case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE: return "_default";
         default: assert(0); return "_unk";
     }
 }
 
+EGLint RenderTestParams::getRenderer() const
+{
+    return requestedRenderer;
+}
+
 ANGLERenderTest::ANGLERenderTest(const std::string &name, const RenderTestParams &testParams)
     : ANGLEPerfTest(name, testParams.suffix()),
       mTestParams(testParams),

src/tests/perf_tests/ANGLEPerfTest.h

@@ -20,6 +20,8 @@
 #include "OSWindow.h"
 #include "Timer.h"
 #include "common/angleutils.h"
+#include "common/debug.h"
+#include "test_utils/angle_test_instantiate.h"
 
 class Event;
 
@@ -54,6 +56,8 @@ struct RenderTestParams
 {
     virtual std::string suffix() const;
 
+    EGLint getRenderer() const;
+
     EGLint requestedRenderer;
     EGLint deviceType;
     EGLint glesMajorVersion;

src/tests/perf_tests/BufferSubData.cpp

@@ -356,8 +356,7 @@ TEST_P(BufferSubDataBenchmark, Run)
     run();
 }
 
-INSTANTIATE_TEST_CASE_P(BufferUpdates,
-                        BufferSubDataBenchmark,
-                        ::testing::Values(BufferUpdateD3D11Params(), BufferUpdateD3D9Params()));
+ANGLE_INSTANTIATE_TEST(BufferSubDataBenchmark,
+                       BufferUpdateD3D11Params(), BufferUpdateD3D9Params());
 
 } // namespace

src/tests/perf_tests/DrawCallPerf.cpp

@@ -206,10 +206,7 @@ TEST_P(DrawCallPerfBenchmark, Run)
     run();
 }
 
-INSTANTIATE_TEST_CASE_P(DrawCallPerf,
-                        DrawCallPerfBenchmark,
-                        ::testing::Values(DrawCallPerfD3D11Params(),
-                                          DrawCallPerfD3D9Params(),
-                                          DrawCallPerfValidationOnly()));
+ANGLE_INSTANTIATE_TEST(DrawCallPerfBenchmark,
+                       DrawCallPerfD3D11Params(), DrawCallPerfD3D9Params(), DrawCallPerfValidationOnly());
 
 } // namespace

src/tests/perf_tests/IndexConversionPerf.cpp

@@ -195,8 +195,7 @@ TEST_P(IndexConversionPerfTest, Run)
     run();
 }
 
-INSTANTIATE_TEST_CASE_P(IndexConversionPerf,
-                        IndexConversionPerfTest,
-                        ::testing::Values(IndexConversionPerfD3D11Params()));
+ANGLE_INSTANTIATE_TEST(IndexConversionPerfTest,
+                       IndexConversionPerfD3D11Params());
 
 } // namespace

src/tests/perf_tests/PointSprites.cpp

@@ -224,6 +224,5 @@ TEST_P(PointSpritesBenchmark, Run)
     run();
 }
 
-INSTANTIATE_TEST_CASE_P(Render,
-                        PointSpritesBenchmark,
-                        ::testing::Values(D3D11Params(), D3D9Params()));
+ANGLE_INSTANTIATE_TEST(PointSpritesBenchmark,
+                       D3D11Params(), D3D9Params());

src/tests/perf_tests/TexSubImage.cpp

@@ -293,6 +293,5 @@ TEST_P(TexSubImageBenchmark, Run)
     run();
 }
 
-INSTANTIATE_TEST_CASE_P(TextureUpdates,
-                        TexSubImageBenchmark,
-                        ::testing::Values(D3D11Params(), D3D9Params()));
+ANGLE_INSTANTIATE_TEST(TexSubImageBenchmark,
+                       D3D11Params(), D3D9Params());

src/tests/test_utils/angle_test_configs.h

@@ -10,7 +10,7 @@
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
-#include "common/debug.h"
+#include "angle_test_instantiate.h"
 #include "EGLWindow.h"
 
 namespace angle
@@ -25,6 +25,8 @@ struct PlatformParameters
     {
     }
 
+    EGLint getRenderer() const { return mEGLPlatformParameters.renderer; }
+
     EGLint mClientVersion;
     EGLPlatformParameters mEGLPlatformParameters;
 
@@ -87,42 +89,6 @@ inline std::ostream &operator<<(std::ostream& stream,
     return stream;
 }
 
-inline std::vector<PlatformParameters> FilterPlatforms(const PlatformParameters *platforms, size_t numPlatforms)
-{
-    std::vector<PlatformParameters> filtered;
-
-    for (size_t i = 0; i < numPlatforms; i++)
-    {
-        switch (platforms[i].mEGLPlatformParameters.renderer)
-        {
-          case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
-#if defined(ANGLE_ENABLE_D3D9)
-            filtered.push_back(platforms[i]);
-#endif
-            break;
-
-          case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
-#if defined(ANGLE_ENABLE_D3D11)
-            filtered.push_back(platforms[i]);
-#endif
-            break;
-
-          case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
-          case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
-#if defined(ANGLE_ENABLE_OPENGL)
-            filtered.push_back(platforms[i]);
-#endif
-            break;
-
-          default:
-            UNREACHABLE();
-            break;
-        }
-    }
-
-    return filtered;
-}
-
 inline PlatformParameters ES2_D3D9()
 {
     EGLPlatformParameters eglParams(
@@ -435,10 +401,6 @@ inline PlatformParameters ES3_OPENGLES()
     return PlatformParameters(3, eglParams);
 }
 
-#define ANGLE_INSTANTIATE_TEST(testName, ...) \
-    const PlatformParameters testName##params[] = {__VA_ARGS__}; \
-    INSTANTIATE_TEST_CASE_P(, testName, testing::ValuesIn(FilterPlatforms(testName##params, ArraySize(testName##params))));
-
 } // namespace angle
 
 #endif // ANGLE_TEST_CONFIGS_H_

src/tests/test_utils/angle_test_instantiate.h

+//
+// Copyright (c) 2014 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.
+//
+
+// angle_test_instantiate.h: Adds support for filtering parameterized
+// tests by platform, so we skip unsupported configs.
+
+#ifndef ANGLE_TEST_INSTANTIATE_H_
+#define ANGLE_TEST_INSTANTIATE_H_
+
+#include "common/debug.h"
+
+namespace angle
+{
+
+// This functions is used to filter which tests should be registered,
+// internally it T::getRenderer() const that should be implemented for test
+// parameter types.
+template <typename T>
+inline std::vector<T> FilterTestParams(const T *params, size_t numParams)
+{
+    std::vector<T> filtered;
+
+    for (size_t i = 0; i < numParams; i++)
+    {
+        switch (params[i].getRenderer())
+        {
+          case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
+            filtered.push_back(params[i]);
+            break;
+
+          case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
+#if defined(ANGLE_ENABLE_D3D9)
+            filtered.push_back(params[i]);
+#endif
+            break;
+
+          case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
+#if defined(ANGLE_ENABLE_D3D11)
+            filtered.push_back(params[i]);
+#endif
+            break;
+
+          case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
+          case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
+#if defined(ANGLE_ENABLE_OPENGL)
+            filtered.push_back(params[i]);
+#endif
+            break;
+
+          default:
+            UNREACHABLE();
+            break;
+        }
+    }
+
+    return filtered;
+}
+
+namespace detail {
+
+// Used with decltype to get the type of the first argument.
+template <typename T, typename ... Args>
+T ReturnFirst(T first, Args...)
+{
+    return first;
+}
+
+} // namespace detail
+
+// Instantiate the test once for each extra argument. The types of all the
+// arguments must match, and getRenderer must be implemented for that type.
+#define ANGLE_INSTANTIATE_TEST(testName, ...) \
+    const decltype(::angle::detail::ReturnFirst(__VA_ARGS__)) testName##params[] = {__VA_ARGS__}; \
+    INSTANTIATE_TEST_CASE_P(, testName, testing::ValuesIn(::angle::FilterTestParams(testName##params, ArraySize(testName##params))));
+
+} // namespace angle
+
+#endif // ANGLE_TEST_INSTANTIATE_H_