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

• Show log

  Commit

• Hash : fdada9ee
  Author :
  Date : 2022-12-13T14:52:53
  

  Re-land: "Make SyncIDs a packed type."
  
  This re-land fixes the sync map size tracking.
  
  This prepares syncs to use a simple resource map like other
  types, which will make life easier in the trace interpreter.
  
  Bug: angleproject:7775
  Change-Id: If2114c51d5b68503890eacbf549182823667fedc
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4178012
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/Fence_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/Fence.h"
  #include "libANGLE/renderer/FenceNVImpl.h"
  #include "libANGLE/renderer/SyncImpl.h"
  #include "tests/angle_unittests_utils.h"
  
  using namespace testing;
  
  namespace
  {
  
  //
  // FenceNV tests
  //
  
  class MockFenceNVImpl : public rx::FenceNVImpl
  {
    public:
      virtual ~MockFenceNVImpl() { destroy(); }
  
      MOCK_METHOD1(onDestroy, void(const gl::Context *context));
      MOCK_METHOD2(set, angle::Result(const gl::Context *, GLenum));
      MOCK_METHOD2(test, angle::Result(const gl::Context *, GLboolean *));
      MOCK_METHOD1(finish, angle::Result(const gl::Context *));
  
      MOCK_METHOD0(destroy, void());
  };
  
  class FenceNVTest : public Test
  {
    protected:
      void SetUp() override
      {
          mImpl = new MockFenceNVImpl;
          EXPECT_CALL(factory, createFenceNV()).WillOnce(Return(mImpl));
  
          EXPECT_CALL(*mImpl, destroy());
          mFence = new gl::FenceNV(&factory);
      }
  
      void TearDown() override { delete mFence; }
  
      NiceMock<rx::MockGLFactory> factory;
      MockFenceNVImpl *mImpl;
      gl::FenceNV *mFence;
  };
  
  TEST_F(FenceNVTest, SetAndTestBehavior)
  {
      EXPECT_CALL(*mImpl, set(_, _)).WillOnce(Return(angle::Result::Continue)).RetiresOnSaturation();
      EXPECT_FALSE(mFence->isSet());
      EXPECT_EQ(angle::Result::Continue, mFence->set(nullptr, GL_ALL_COMPLETED_NV));
      EXPECT_TRUE(mFence->isSet());
      // Fake the behavior of testing the fence before and after it's passed.
      EXPECT_CALL(*mImpl, test(_, _))
          .WillOnce(DoAll(SetArgumentPointee<1>(static_cast<GLboolean>(GL_FALSE)),
                          Return(angle::Result::Continue)))
          .WillOnce(DoAll(SetArgumentPointee<1>(static_cast<GLboolean>(GL_TRUE)),
                          Return(angle::Result::Continue)))
          .RetiresOnSaturation();
      GLboolean out;
      EXPECT_EQ(angle::Result::Continue, mFence->test(nullptr, &out));
      EXPECT_EQ(GL_FALSE, out);
      EXPECT_EQ(angle::Result::Continue, mFence->test(nullptr, &out));
      EXPECT_EQ(GL_TRUE, out);
  }
  
  //
  // Sync tests
  //
  
  class MockSyncImpl : public rx::SyncImpl
  {
    public:
      virtual ~MockSyncImpl() { destroy(); }
  
      MOCK_METHOD3(set, angle::Result(const gl::Context *, GLenum, GLbitfield));
      MOCK_METHOD4(clientWait, angle::Result(const gl::Context *, GLbitfield, GLuint64, GLenum *));
      MOCK_METHOD3(serverWait, angle::Result(const gl::Context *, GLbitfield, GLuint64));
      MOCK_METHOD2(getStatus, angle::Result(const gl::Context *, GLint *));
  
      MOCK_METHOD0(destroy, void());
  };
  
  class FenceSyncTest : public Test
  {
    protected:
      void SetUp() override
      {
          mImpl = new MockSyncImpl;
          EXPECT_CALL(factory, createSync()).WillOnce(Return(mImpl));
  
          mFence = new gl::Sync(&factory, {1});
          EXPECT_CALL(*mImpl, destroy());
          mFence->addRef();
      }
  
      void TearDown() override { mFence->release(nullptr); }
  
      NiceMock<rx::MockGLFactory> factory;
      MockSyncImpl *mImpl;
      gl::Sync *mFence;
  };
  
  TEST_F(FenceSyncTest, SetAndGetStatusBehavior)
  {
      EXPECT_CALL(*mImpl, set(_, _, _))
          .WillOnce(Return(angle::Result::Continue))
          .RetiresOnSaturation();
      EXPECT_EQ(angle::Result::Continue, mFence->set(nullptr, GL_SYNC_GPU_COMMANDS_COMPLETE, 0));
      EXPECT_EQ(static_cast<GLenum>(GL_SYNC_GPU_COMMANDS_COMPLETE), mFence->getCondition());
      // Fake the behavior of testing the fence before and after it's passed.
      EXPECT_CALL(*mImpl, getStatus(_, _))
          .WillOnce(DoAll(SetArgumentPointee<1>(GL_UNSIGNALED), Return(angle::Result::Continue)))
          .WillOnce(DoAll(SetArgumentPointee<1>(GL_SIGNALED), Return(angle::Result::Continue)))
          .RetiresOnSaturation();
      GLint out;
      EXPECT_EQ(angle::Result::Continue, mFence->getStatus(nullptr, &out));
      EXPECT_EQ(GL_UNSIGNALED, out);
      EXPECT_EQ(angle::Result::Continue, mFence->getStatus(nullptr, &out));
      EXPECT_EQ(GL_SIGNALED, out);
  }
  
  }  // namespace
  

Download