kc3-lang/angle/src/libANGLE/TransformFeedback_unittest.cpp

• Show log

  Commit

• Hash : 4c7db77e
  Author :
  Date : 2019-10-31T15:42:31
  

  Vulkan: Set limitation on maxComputeWorkGroupCount
  
  According to Table 20.45 and Chapter 17 in the ES 3.1 spec, MAX_COMPUTE_WORK_GROUP_COUNT
  is get as a GLint by using GetIntegeri_v. However, it is an unsigned integer
  in the Vulkan. It needs to set limitation on maxComputeWorkGroupCount[] during
  translating.
  
  1. Change the data type to GLint stored in Caps.
  2. Ensure that the limitation is set during initialization.
  3. Add workaround for angleproject:4120
  
  Bug: angleproject:4066
  Change-Id: I1659ba1d560e30b9599cace0feeab8a18890c3ff
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1890586
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Ian Elliott <ianelliott@google.com>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/TransformFeedback_unittest.cpp

• //
  // Copyright 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.
  //
  
  #include "gmock/gmock.h"
  #include "gtest/gtest.h"
  
  #include "libANGLE/Buffer.h"
  #include "libANGLE/Caps.h"
  #include "libANGLE/TransformFeedback.h"
  #include "libANGLE/renderer/BufferImpl_mock.h"
  #include "libANGLE/renderer/TransformFeedbackImpl_mock.h"
  #include "tests/angle_unittests_utils.h"
  
  using ::testing::_;
  using ::testing::get;
  using ::testing::Return;
  using ::testing::SetArgumentPointee;
  
  namespace
  {
  
  ACTION(CreateMockTransformFeedbackImpl)
  {
      return new rx::MockTransformFeedbackImpl(arg0);
  }
  
  class TransformFeedbackTest : public testing::Test
  {
    protected:
      TransformFeedbackTest() : mImpl(nullptr), mFeedback(nullptr) {}
  
      void SetUp() override
      {
          EXPECT_CALL(mMockFactory, createTransformFeedback(_))
              .WillOnce(CreateMockTransformFeedbackImpl())
              .RetiresOnSaturation();
  
          // Set a reasonable number of tf attributes
          mCaps.maxTransformFeedbackSeparateAttributes = 8;
  
          mFeedback = new gl::TransformFeedback(&mMockFactory, gl::TransformFeedbackID{1}, mCaps);
          mFeedback->addRef();
  
          mImpl = rx::GetImplAs<rx::MockTransformFeedbackImpl>(mFeedback);
          EXPECT_CALL(*mImpl, destructor());
      }
  
      void TearDown() override
      {
          if (mFeedback)
          {
              mFeedback->release(nullptr);
          }
  
          // Only needed because the mock is leaked if bugs are present,
          // which logs an error, but does not cause the test to fail.
          // Ordinarily mocks are verified when destroyed.
          testing::Mock::VerifyAndClear(mImpl);
      }
  
      rx::MockGLFactory mMockFactory;
      rx::MockTransformFeedbackImpl *mImpl;
      gl::TransformFeedback *mFeedback;
      gl::Caps mCaps;
  };
  
  TEST_F(TransformFeedbackTest, SideEffectsOfStartAndStop)
  {
      testing::InSequence seq;
  
      EXPECT_FALSE(mFeedback->isActive());
      EXPECT_CALL(*mImpl, begin(nullptr, gl::PrimitiveMode::Triangles));
      EXPECT_EQ(angle::Result::Continue,
                mFeedback->begin(nullptr, gl::PrimitiveMode::Triangles, nullptr));
      EXPECT_TRUE(mFeedback->isActive());
      EXPECT_EQ(gl::PrimitiveMode::Triangles, mFeedback->getPrimitiveMode());
      EXPECT_CALL(*mImpl, end(nullptr));
      EXPECT_EQ(angle::Result::Continue, mFeedback->end(nullptr));
      EXPECT_FALSE(mFeedback->isActive());
  }
  
  TEST_F(TransformFeedbackTest, SideEffectsOfPauseAndResume)
  {
      testing::InSequence seq;
  
      EXPECT_FALSE(mFeedback->isActive());
      EXPECT_CALL(*mImpl, begin(nullptr, gl::PrimitiveMode::Triangles));
      EXPECT_EQ(angle::Result::Continue,
                mFeedback->begin(nullptr, gl::PrimitiveMode::Triangles, nullptr));
      EXPECT_FALSE(mFeedback->isPaused());
      EXPECT_CALL(*mImpl, pause(nullptr));
      EXPECT_EQ(angle::Result::Continue, mFeedback->pause(nullptr));
      EXPECT_TRUE(mFeedback->isPaused());
      EXPECT_CALL(*mImpl, resume(nullptr));
      EXPECT_EQ(angle::Result::Continue, mFeedback->resume(nullptr));
      EXPECT_FALSE(mFeedback->isPaused());
      EXPECT_CALL(*mImpl, end(nullptr));
      EXPECT_EQ(angle::Result::Continue, mFeedback->end(nullptr));
  }
  
  TEST_F(TransformFeedbackTest, BufferBinding)
  {
      rx::MockBufferImpl *bufferImpl = new rx::MockBufferImpl;
      EXPECT_CALL(*bufferImpl, destructor()).Times(1).RetiresOnSaturation();
  
      rx::MockGLFactory mockGLFactory;
      EXPECT_CALL(mockGLFactory, createBuffer(_))
          .Times(1)
          .WillOnce(Return(bufferImpl))
          .RetiresOnSaturation();
  
      gl::Buffer *buffer = new gl::Buffer(&mockGLFactory, {1});
  
      static const size_t bindIndex = 0;
  
      EXPECT_EQ(mFeedback->getIndexedBufferCount(),
                static_cast<GLuint>(mCaps.maxTransformFeedbackSeparateAttributes));
  
      EXPECT_CALL(*mImpl, bindIndexedBuffer(_, _, _));
      EXPECT_EQ(angle::Result::Continue,
                mFeedback->bindIndexedBuffer(nullptr, bindIndex, buffer, 0, 1));
      for (size_t i = 0; i < mFeedback->getIndexedBufferCount(); i++)
      {
          if (i == bindIndex)
          {
              EXPECT_EQ(mFeedback->getIndexedBuffer(i).get(), buffer);
          }
          else
          {
              EXPECT_EQ(mFeedback->getIndexedBuffer(i).get(), nullptr);
          }
      }
  
      // force-release the feedback object to ensure the buffer is released.
      const size_t releaseCount = mFeedback->getRefCount();
      for (size_t count = 0; count < releaseCount; ++count)
      {
          mFeedback->release(nullptr);
      }
  
      mFeedback = nullptr;
  
      testing::Mock::VerifyAndClear(bufferImpl);
  }
  
  }  // anonymous namespace
  

Download