Add a GLES3 GoogleTest target.

src/tests/deqp.gypi

@@ -1123,6 +1123,13 @@
                     [
                         'ANGLE_DEQP_GLES2_TESTS',
                     ],
+                    'direct_dependent_settings':
+                    {
+                        'defines':
+                        [
+                            'ANGLE_DEQP_GLES2_TESTS',
+                        ],
+                    },
                     'sources':
                     [
                         '<@(deqp_gles2_sources)',
@@ -1143,6 +1150,13 @@
                     [
                         'ANGLE_DEQP_GLES3_TESTS',
                     ],
+                    'direct_dependent_settings':
+                    {
+                        'defines':
+                        [
+                            'ANGLE_DEQP_GLES3_TESTS',
+                        ],
+                    },
                     'sources':
                     [
                         '<@(deqp_gles3_sources)',
@@ -1158,7 +1172,6 @@
                     'type': 'none',
                     'dependencies':
                     [
-                        'angle_deqp_libgles2',
                         'angle_test_support',
                         '<(angle_path)/util/util.gyp:angle_util',
                     ],
@@ -1216,6 +1229,21 @@
                                 ],
                             },
                         },
+
+                        'conditions':
+                        [
+                            ['OS=="linux"',
+                            {
+                                'ldflags':
+                                [
+                                    '<!@(pkg-config --libs-only-L --libs-only-other libpci)',
+                                ],
+                                'libraries':
+                                [
+                                    '<!@(pkg-config --libs-only-l libpci)',
+                                ],
+                            }],
+                        ],
                     },
 
                     'conditions':
@@ -1264,30 +1292,32 @@
                 },
 
                 {
-                    'target_name': 'angle_deqp_googletest',
+                    'target_name': 'angle_deqp_gtest_gles2_tests',
                     'type': 'executable',
                     'includes': [ '../../build/common_defines.gypi', ],
                     'dependencies':
                     [
                         'angle_deqp_gtest_support',
+                        'angle_deqp_libgles2',
                     ],
                     'sources':
                     [
                         'deqp_support/angle_deqp_gtest_main.cpp',
                     ],
-                    'conditions':
+                },
+
+                {
+                    'target_name': 'angle_deqp_gtest_gles3_tests',
+                    'type': 'executable',
+                    'includes': [ '../../build/common_defines.gypi', ],
+                    'dependencies':
                     [
-                        ['OS=="linux"',
-                        {
-                            'ldflags':
-                            [
-                                '<!@(pkg-config --libs-only-L --libs-only-other libpci)',
-                            ],
-                            'libraries':
-                            [
-                                '<!@(pkg-config --libs-only-l libpci)',
-                            ],
-                        }],
+                        'angle_deqp_gtest_support',
+                        'angle_deqp_libgles3',
+                    ],
+                    'sources':
+                    [
+                        'deqp_support/angle_deqp_gtest_main.cpp',
                     ],
                 },
             ], # targets

src/tests/deqp_support/angle_deqp_gtest.cpp

@@ -21,10 +21,22 @@
 namespace
 {
 
+const char *g_CaseListFiles[] =
+{
+    "dEQP-GLES2-cases.txt.gz",
+    "dEQP-GLES3-cases.txt.gz",
+};
+
+const char *g_TestExpectationsFiles[] =
+{
+    "deqp_test_expectations.txt",
+    "deqp_test_expectations.txt",
+};
+
 class dEQPCaseList
 {
   public:
-    dEQPCaseList(const std::string &caseListPath, const std::string &testExpectationsPath);
+    dEQPCaseList(size_t testModuleIndex);
 
     struct CaseInfo
     {
@@ -53,42 +65,25 @@ class dEQPCaseList
         return mCaseInfoList.size();
     }
 
-    static dEQPCaseList *GetInstance();
-    static void FreeInstance();
-
   private:
     std::vector<CaseInfo> mCaseInfoList;
     gpu::GPUTestExpectationsParser mTestExpectationsParser;
     gpu::GPUTestBotConfig mTestConfig;
-
-    static dEQPCaseList *mInstance;
 };
 
-// static
-dEQPCaseList *dEQPCaseList::mInstance = nullptr;
-
-// static
-dEQPCaseList *dEQPCaseList::GetInstance()
+dEQPCaseList::dEQPCaseList(size_t testModuleIndex)
 {
-    if (mInstance == nullptr)
-    {
-        std::string exeDir = angle::GetExecutableDirectory();
-        std::string caseListPath = exeDir + "/deqp_support/dEQP-GLES2-cases.txt.gz";
-        std::string testExpectationsPath = exeDir + "/deqp_support/deqp_test_expectations.txt";
-        mInstance = new dEQPCaseList(caseListPath, testExpectationsPath);
-    }
-    return mInstance;
-}
+    std::string exeDir = angle::GetExecutableDirectory();
 
-// Not currently called, assumed to be freed on program exit.
-// static
-void dEQPCaseList::FreeInstance()
-{
-    SafeDelete(mInstance);
-}
+    std::stringstream caseListPathStr;
+    caseListPathStr << exeDir << "/deqp_support/" << g_CaseListFiles[testModuleIndex];
+    std::string caseListPath = caseListPathStr.str();
+
+    std::stringstream testExpectationsPathStr;
+    testExpectationsPathStr << exeDir << "/deqp_support/"
+                            << g_TestExpectationsFiles[testModuleIndex];
+    std::string testExpectationsPath = testExpectationsPathStr.str();
 
-dEQPCaseList::dEQPCaseList(const std::string &caseListPath, const std::string &testExpectationsPath)
-{
     if (!mTestExpectationsParser.LoadTestExpectationsFromFile(testExpectationsPath))
     {
         std::cerr << "Failed to load test expectations." << std::endl;
@@ -147,17 +142,29 @@ dEQPCaseList::dEQPCaseList(const std::string &caseListPath, const std::string &t
     }
 }
 
-class dEQP_GLES2 : public testing::TestWithParam<size_t>
+template <size_t TestModuleIndex>
+class dEQPTest : public testing::TestWithParam<size_t>
 {
-  protected:
-    dEQP_GLES2() {}
+  public:
+    static testing::internal::ParamGenerator<size_t> GetTestingRange()
+    {
+        return testing::Range<size_t>(0, GetCaseList().numCases());
+    }
+
+    static const dEQPCaseList &GetCaseList()
+    {
+        static dEQPCaseList sCaseList(TestModuleIndex);
+        return sCaseList;
+    }
 
+  protected:
     void runTest()
     {
-        const auto &caseInfo = dEQPCaseList::GetInstance()->getCaseInfo(GetParam());
+        const auto &caseInfo = GetCaseList().getCaseInfo(GetParam());
         std::cout << caseInfo.mDEQPName << std::endl;
 
         bool result = deqp_libtester_run(caseInfo.mDEQPName.c_str());
+
         if (caseInfo.mExpectation == gpu::GPUTestExpectationsParser::kGpuTestPass)
         {
             EXPECT_TRUE(result);
@@ -169,17 +176,31 @@ class dEQP_GLES2 : public testing::TestWithParam<size_t>
     }
 };
 
+class dEQP_GLES2 : public dEQPTest<0>
+{
+};
+
+class dEQP_GLES3 : public dEQPTest<1>
+{
+};
+
+#ifdef ANGLE_DEQP_GLES2_TESTS
 // TODO(jmadill): add different platform configs, or ability to choose platform
 TEST_P(dEQP_GLES2, Default)
 {
     runTest();
 }
 
-testing::internal::ParamGenerator<size_t> GetTestingRange()
+INSTANTIATE_TEST_CASE_P(, dEQP_GLES2, dEQP_GLES2::GetTestingRange());
+#endif
+
+#ifdef ANGLE_DEQP_GLES3_TESTS
+TEST_P(dEQP_GLES3, Default)
 {
-    return testing::Range<size_t>(0, dEQPCaseList::GetInstance()->numCases());
+    runTest();
 }
 
-INSTANTIATE_TEST_CASE_P(, dEQP_GLES2, GetTestingRange());
+INSTANTIATE_TEST_CASE_P(, dEQP_GLES3, dEQP_GLES3::GetTestingRange());
+#endif
 
 } // anonymous namespace

src/tests/deqp_support/tcuANGLEPlatform.cpp

@@ -36,7 +36,6 @@ ANGLEPlatform::ANGLEPlatform()
     angle::SetLowPriorityProcess();
 
 #if (DE_OS == DE_OS_WIN32)
-#if defined(ANGLE_DEQP_GLES2_TESTS) || defined(ANGLE_DEQP_GLES3_TESTS)
     std::vector<eglw::EGLAttrib> d3d11Attribs;
     d3d11Attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
     d3d11Attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE);
@@ -47,9 +46,7 @@ ANGLEPlatform::ANGLEPlatform()
     auto *d3d11Factory = new ANGLENativeDisplayFactory(
         "angle-d3d11", "ANGLE D3D11 Display", d3d11Attribs, &mEvents);
     m_nativeDisplayFactoryRegistry.registerFactory(d3d11Factory);
-#endif // defined(ANGLE_DEQP_GLES2_TESTS) || defined(ANGLE_DEQP_GLES3_TESTS)
 
-#if defined(ANGLE_DEQP_GLES2_TESTS)
     std::vector<eglw::EGLAttrib> d3d9Attribs;
     d3d9Attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
     d3d9Attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE);
@@ -75,10 +72,8 @@ ANGLEPlatform::ANGLEPlatform()
     auto *d3d1193Factory = new ANGLENativeDisplayFactory(
         "angle-d3d11-fl93", "ANGLE D3D11 FL9_3 Display", d3d1193Attribs, &mEvents);
     m_nativeDisplayFactoryRegistry.registerFactory(d3d1193Factory);
-#endif // defined(ANGLE_DEQP_GLES2_TESTS)
 #endif // (DE_OS == DE_OS_WIN32)
 
-#if defined(ANGLE_DEQP_GLES2_TESTS)
     std::vector<eglw::EGLAttrib> glAttribs;
     glAttribs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
     glAttribs.push_back(EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE);
@@ -87,7 +82,6 @@ ANGLEPlatform::ANGLEPlatform()
     auto *glFactory = new ANGLENativeDisplayFactory(
         "angle-gl", "ANGLE OpenGL Display", glAttribs, &mEvents);
     m_nativeDisplayFactoryRegistry.registerFactory(glFactory);
-#endif // defined(ANGLE_DEQP_GLES2_TESTS)
 
     m_contextFactoryRegistry.registerFactory(new eglu::GLContextFactory(m_nativeDisplayFactoryRegistry));