kc3-lang/angle/src/tests/deqp_support/angle_deqp_gtest.cpp

• Show log

  Commit

• Hash : 5111a062
  Author :
  Date : 2015-11-30T10:31:36
  

  Update dEQP integration.
  
  Intead of generating a case list from a build dEQP executable and
  packing it into a gzip file, we can use the Android CTS mustpass
  list. This has the benefit of allowing us to remove some failure
  expectations for broken tests. It also means we don't need to
  ever regenerate our case list files.
  
  Also remove the old dEQP test integration, since it is no longer
  supported or possibly even working.
  
  And update our test expectations to match the new Android CTS
  must-pass lists.
  
  This change will likely need to be landed simulatanously with a
  Chromium-side CL, due to the nature of the gyp/DEPS configuration.
  
  BUG=angleproject:1236
  
  Change-Id: I352e4a651dfb88193a1c4991974502dee1edb67b
  Reviewed-on: https://chromium-review.googlesource.com/313792
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/tests/deqp_support/angle_deqp_gtest.cpp

• //
  // Copyright 2015 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_deqp_gtest:
  //   dEQP and GoogleTest integration logic. Calls through to the random
  //   order executor.
  
  #include <fstream>
  #include <stdint.h>
  
  #include <gtest/gtest.h>
  
  #include "angle_deqp_libtester.h"
  #include "common/angleutils.h"
  #include "common/debug.h"
  #include "common/Optional.h"
  #include "common/string_utils.h"
  #include "gpu_test_expectations_parser.h"
  #include "system_utils.h"
  
  namespace
  {
  
  const char *g_CaseListRelativePath = "/../../third_party/deqp/src/android/cts/master/";
  
  const char *g_TestExpectationsSearchPaths[] = {
      "/../../src/tests/deqp_support/", "/../../third_party/angle/src/tests/deqp_support/",
      "/deqp_support/",
  };
  
  const char *g_CaseListFiles[] = {
      "gles2-master.txt", "gles3-master.txt", "egl-master.txt",
  };
  
  const char *g_TestExpectationsFiles[] =
  {
      "deqp_gles2_test_expectations.txt",
      "deqp_gles3_test_expectations.txt",
      "deqp_egl_test_expectations.txt",
  };
  
  Optional<std::string> FindTestExpectationsPath(const std::string &exeDir, size_t testModuleIndex)
  {
      for (const char *testPath : g_TestExpectationsSearchPaths)
      {
          std::stringstream testExpectationsPathStr;
          testExpectationsPathStr << exeDir << testPath << g_TestExpectationsFiles[testModuleIndex];
  
          std::string path = testExpectationsPathStr.str();
          std::ifstream inFile(path.c_str());
          if (!inFile.fail())
          {
              inFile.close();
              return Optional<std::string>(path);
          }
      }
  
      return Optional<std::string>::Invalid();
  }
  
  class dEQPCaseList
  {
    public:
      dEQPCaseList(size_t testModuleIndex);
  
      struct CaseInfo
      {
          CaseInfo(const std::string &dEQPName,
                   const std::string &gTestName,
                   int expectation)
              : mDEQPName(dEQPName),
                mGTestName(gTestName),
                mExpectation(expectation)
          {
          }
  
          std::string mDEQPName;
          std::string mGTestName;
          int mExpectation;
      };
  
      void initialize();
  
      const CaseInfo &getCaseInfo(size_t caseIndex) const
      {
          ASSERT(mInitialized);
          ASSERT(caseIndex < mCaseInfoList.size());
          return mCaseInfoList[caseIndex];
      }
  
      size_t numCases() const
      {
          ASSERT(mInitialized);
          return mCaseInfoList.size();
      }
  
    private:
      std::vector<CaseInfo> mCaseInfoList;
      gpu::GPUTestExpectationsParser mTestExpectationsParser;
      gpu::GPUTestBotConfig mTestConfig;
      size_t mTestModuleIndex;
      bool mInitialized;
  };
  
  dEQPCaseList::dEQPCaseList(size_t testModuleIndex)
      : mTestModuleIndex(testModuleIndex),
        mInitialized(false)
  {
  }
  
  void dEQPCaseList::initialize()
  {
      if (mInitialized)
      {
          return;
      }
  
      mInitialized = true;
  
      std::string exeDir = angle::GetExecutableDirectory();
  
      std::stringstream caseListPathStr;
      caseListPathStr << exeDir << g_CaseListRelativePath << g_CaseListFiles[mTestModuleIndex];
      std::string caseListPath = caseListPathStr.str();
  
      Optional<std::string> testExpectationsPath = FindTestExpectationsPath(exeDir, mTestModuleIndex);
      if (!testExpectationsPath.valid())
      {
          FAIL() << "Failed to find test expectations file.";
      }
  
      if (!mTestExpectationsParser.LoadTestExpectationsFromFile(testExpectationsPath.value()))
      {
          std::stringstream errorMsgStream;
          for (const auto &message : mTestExpectationsParser.GetErrorMessages())
          {
              errorMsgStream << std::endl << " " << message;
          }
  
          FAIL() << "Failed to load test expectations." << errorMsgStream.str();
      }
  
      if (!mTestConfig.LoadCurrentConfig(nullptr))
      {
          FAIL() << "Failed to load test configuration.";
      }
  
      std::ifstream caseListStream(caseListPath);
  
      while (!caseListStream.eof())
      {
          std::string inString;
          std::getline(caseListStream, inString);
  
          std::string dEQPName = angle::TrimString(inString, angle::kWhitespaceASCII);
          if (dEQPName.empty())
              continue;
          std::string gTestName = dEQPName.substr(dEQPName.find('.') + 1);
          if (gTestName.empty())
              continue;
          std::replace(gTestName.begin(), gTestName.end(), '.', '_');
  
          // Occurs in some luminance tests
          gTestName.erase(std::remove(gTestName.begin(), gTestName.end(), '-'), gTestName.end());
  
          int expectation = mTestExpectationsParser.GetTestExpectation(dEQPName, mTestConfig);
          if (expectation != gpu::GPUTestExpectationsParser::kGpuTestSkip)
          {
              mCaseInfoList.push_back(CaseInfo(dEQPName, gTestName, expectation));
          }
      }
  }
  
  template <size_t TestModuleIndex>
  class dEQPTest : public testing::TestWithParam<size_t>
  {
    public:
      static testing::internal::ParamGenerator<size_t> GetTestingRange()
      {
          return testing::Range<size_t>(0, GetCaseList().numCases());
      }
  
      static std::string GetCaseGTestName(size_t caseIndex)
      {
          const auto &caseInfo = GetCaseList().getCaseInfo(caseIndex);
          return caseInfo.mGTestName;
      }
  
      static const dEQPCaseList &GetCaseList()
      {
          static dEQPCaseList sCaseList(TestModuleIndex);
          sCaseList.initialize();
          return sCaseList;
      }
  
    protected:
      void runTest()
      {
          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);
          }
          else if (result)
          {
              std::cout << "Test expected to fail but passed!" << std::endl;
          }
      }
  };
  
  class dEQP_GLES2 : public dEQPTest<0>
  {
  };
  
  class dEQP_GLES3 : public dEQPTest<1>
  {
  };
  
  class dEQP_EGL : public dEQPTest<2>
  {
  };
  
  // TODO(jmadill): add different platform configs, or ability to choose platform
  #define ANGLE_INSTANTIATE_DEQP_TEST_CASE(DEQP_TEST)                             \
      TEST_P(DEQP_TEST, Default) { runTest(); }                                   \
                                                                                  \
      INSTANTIATE_TEST_CASE_P(, DEQP_TEST, DEQP_TEST::GetTestingRange(),          \
                              [](const testing::TestParamInfo<size_t> &info)      \
                              {                                                   \
                                  return DEQP_TEST::GetCaseGTestName(info.param); \
                              })
  
  #ifdef ANGLE_DEQP_GLES2_TESTS
  ANGLE_INSTANTIATE_DEQP_TEST_CASE(dEQP_GLES2);
  #endif
  
  #ifdef ANGLE_DEQP_GLES3_TESTS
  ANGLE_INSTANTIATE_DEQP_TEST_CASE(dEQP_GLES3);
  #endif
  
  #ifdef ANGLE_DEQP_EGL_TESTS
  ANGLE_INSTANTIATE_DEQP_TEST_CASE(dEQP_EGL);
  #endif
  
  } // anonymous namespace
  

Download