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

• Show log

  Commit

• Hash : 520c4ae2
  Author :
  Date : 2015-05-05T13:12:36
  

  Add a Buffer::getIndexRange function.
  
  Instead of exposing the index range cache, add a more generic method that
  allows the buffers to handle their own caching of index ranges.
  BufferImpl::getData can be hard to implement for BufferGL because there
  isn't a way to tell the buffer to unmap and glGetBufferSubData can be very
  expensive, requiring an extra copy of the data.
  
  BUG=angleproject:881
  
  Change-Id: Idec645219056132e0d72a410fbe7b971fa02c9e9
  Reviewed-on: https://chromium-review.googlesource.com/261892
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>
  Tested-by: Geoff Lang <geofflang@chromium.org>
  

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"
  
  using ::testing::_;
  using ::testing::Return;
  using ::testing::SetArgumentPointee;
  
  namespace
  {
  
  class TransformFeedbackTest : public testing::Test
  {
    protected:
      virtual void SetUp()
      {
          // Set a reasonable number of tf attributes
          mCaps.maxTransformFeedbackSeparateAttributes = 8;
  
          mImpl = new rx::MockTransformFeedbackImpl;
          EXPECT_CALL(*mImpl, destructor());
          mFeedback = new gl::TransformFeedback(mImpl, 1, mCaps);
          mFeedback->addRef();
      }
  
      virtual void TearDown()
      {
          mFeedback->release();
      }
  
      rx::MockTransformFeedbackImpl* mImpl;
      gl::TransformFeedback* mFeedback;
      gl::Caps mCaps;
  };
  
  TEST_F(TransformFeedbackTest, DestructionDeletesImpl)
  {
      rx::MockTransformFeedbackImpl* impl = new rx::MockTransformFeedbackImpl;
      EXPECT_CALL(*impl, destructor()).Times(1).RetiresOnSaturation();
  
      gl::TransformFeedback* feedback = new gl::TransformFeedback(impl, 1, mCaps);
      feedback->addRef();
      feedback->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(impl);
  }
  
  TEST_F(TransformFeedbackTest, SideEffectsOfStartAndStop)
  {
      testing::InSequence seq;
  
      EXPECT_FALSE(mFeedback->isActive());
      EXPECT_CALL(*mImpl, begin(GL_TRIANGLES));
      mFeedback->begin(GL_TRIANGLES);
      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);
      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;
  
      rx::MockTransformFeedbackImpl *feedbackImpl = new rx::MockTransformFeedbackImpl;
      EXPECT_CALL(*feedbackImpl, destructor()).Times(1).RetiresOnSaturation();
  
      gl::TransformFeedback *feedback = new gl::TransformFeedback(feedbackImpl, 1, mCaps);
  
      EXPECT_EQ(feedback->getIndexedBufferCount(), mCaps.maxTransformFeedbackSeparateAttributes);
  
      EXPECT_CALL(*feedbackImpl, bindGenericBuffer(_));
      feedback->bindGenericBuffer(buffer);
      EXPECT_EQ(feedback->getGenericBuffer().get(), buffer);
  
      EXPECT_CALL(*feedbackImpl, bindIndexedBuffer(_, _));
      feedback->bindIndexedBuffer(bindIndex, buffer, 0, 1);
      for (size_t i = 0; i < feedback->getIndexedBufferCount(); i++)
      {
          if (i == bindIndex)
          {
              EXPECT_EQ(feedback->getIndexedBuffer(i).get(), buffer);
          }
          else
          {
              EXPECT_EQ(feedback->getIndexedBuffer(i).get(), nullptr);
          }
      }
  
      feedback->addRef();
      feedback->release();
  
      testing::Mock::VerifyAndClear(bufferImpl);
  }
  
  } // namespace
  

Download