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

• Show log

  Commit

• Hash : c3e55a43
  Author :
  Date : 2016-03-09T16:29:18
  

  Validate program changes wrt transform feedback
  
  UseProgram can't be called while transform feedback is active and
  unpaused. Validate this by checking the presence of active transform
  feedback in UseProgram.
  
  LinkProgram or ProgramBinary can't be called while transform feedback
  associated with the program is active. Validate this by going through
  all of the existing transform feedback objects when one of these
  functions is called and checking whether they are associated with the
  program being changed. A program association is added to
  gl::TransformFeedback to facilitate this.
  
  BeginTransformFeedback can't be used to unpause a transform feedback
  object, so code for that is removed.
  
  The validation of the entry points touched in this patch is refactored
  to follow the current convention of separate Validate* functions,
  though with LinkProgram following this convention fully isn't
  practical.
  
  This patch also makes sure that ANGLE doesn't invoke behavior that the
  GL spec doesn't specify if a program object associated with a paused
  transform feedback is deleted.
  
  Tests are edited so that they don't call UseProgram when it generates
  an error.
  
  BUG=angleproject:1101
  TEST=dEQP-GLES3.functional.negative_api.shader.* (2 more tests pass),
       dEQP-GLES3.functional.transform_feedback.* (no regressions),
       angle_end2end_tests
  
  Change-Id: I2e5b3a027ced11249b762ec01a29fa41d2c0dd96
  Reviewed-on: https://chromium-review.googlesource.com/332141
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/libANGLE/TransformFeedback_unittest.cpp

• //
  // 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.
  //
  
  #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::Return;
  using ::testing::SetArgumentPointee;
  
  namespace
  {
  
  class MockFactory : public rx::NullFactory
  {
    public:
      MOCK_METHOD0(createTransformFeedback, rx::TransformFeedbackImpl *());
  };
  
  class TransformFeedbackTest : public testing::Test
  {
    protected:
      TransformFeedbackTest() : mImpl(nullptr), mFeedback(nullptr) {}
  
      void SetUp() override
      {
          mImpl = new rx::MockTransformFeedbackImpl;
          EXPECT_CALL(mMockFactory, createTransformFeedback())
              .WillOnce(Return(mImpl))
              .RetiresOnSaturation();
  
          // Set a reasonable number of tf attributes
          mCaps.maxTransformFeedbackSeparateAttributes = 8;
  
          EXPECT_CALL(*mImpl, destructor());
          mFeedback = new gl::TransformFeedback(&mMockFactory, 1, mCaps);
          mFeedback->addRef();
      }
  
      void TearDown() override
      {
          if (mFeedback)
          {
              mFeedback->release();
          }
  
          // 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);
      }
  
      MockFactory 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(GL_TRIANGLES));
      mFeedback->begin(GL_TRIANGLES, nullptr);
      EXPECT_TRUE(mFeedback->isActive());
      EXPECT_EQ(static_cast<GLenum>(GL_TRIANGLES), mFeedback->getPrimitiveMode());
      EXPECT_CALL(*mImpl, end());
      mFeedback->end();
      EXPECT_FALSE(mFeedback->isActive());
  }
  
  TEST_F(TransformFeedbackTest, SideEffectsOfPauseAndResume)
  {
      testing::InSequence seq;
  
      EXPECT_FALSE(mFeedback->isActive());
      EXPECT_CALL(*mImpl, begin(GL_TRIANGLES));
      mFeedback->begin(GL_TRIANGLES, nullptr);
      EXPECT_FALSE(mFeedback->isPaused());
      EXPECT_CALL(*mImpl, pause());
      mFeedback->pause();
      EXPECT_TRUE(mFeedback->isPaused());
      EXPECT_CALL(*mImpl, resume());
      mFeedback->resume();
      EXPECT_FALSE(mFeedback->isPaused());
      EXPECT_CALL(*mImpl, end());
      mFeedback->end();
  }
  
  TEST_F(TransformFeedbackTest, BufferBinding)
  {
      rx::MockBufferImpl *bufferImpl = new rx::MockBufferImpl;
      gl::Buffer *buffer = new gl::Buffer(bufferImpl, 1);
      EXPECT_CALL(*bufferImpl, destructor()).Times(1).RetiresOnSaturation();
  
      static const size_t bindIndex = 0;
  
      EXPECT_EQ(mFeedback->getIndexedBufferCount(), mCaps.maxTransformFeedbackSeparateAttributes);
  
      EXPECT_CALL(*mImpl, bindGenericBuffer(_));
      mFeedback->bindGenericBuffer(buffer);
      EXPECT_EQ(mFeedback->getGenericBuffer().get(), buffer);
  
      EXPECT_CALL(*mImpl, bindIndexedBuffer(_, _));
      mFeedback->bindIndexedBuffer(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();
      }
  
      mFeedback = nullptr;
  
      testing::Mock::VerifyAndClear(bufferImpl);
  }
  
  }  // anonymous namespace
  

Download