From caa549c0fa41063712cad5a2681084c1f5837fea Mon Sep 17 00:00:00 2001 From: Kenneth Russell Date: Fri, 10 Oct 2014 17:52:59 -0700 Subject: Split FenceImpl into FenceNVImpl and FenceSyncImpl, and refactor. Move Windows-specific code out of Fence.cpp. Split FenceImpl based on suggestions on previous review https://chromium-review.googlesource.com/221805/ . Refactored further based on code review feedback and added first unit tests. BUG=angleproject:774 Change-Id: I630034e1788e48ddb7722016ca22da474e785798 Reviewed-on: https://chromium-review.googlesource.com/222954 Reviewed-by: Kenneth Russell Tested-by: Kenneth Russell --- .../Fence_unittest.cpp | 162 +++++++++++++++++++++ 1 file changed, 162 insertions(+) create mode 100644 tests/angle_implementation_unit_tests/Fence_unittest.cpp (limited to 'tests') diff --git a/tests/angle_implementation_unit_tests/Fence_unittest.cpp b/tests/angle_implementation_unit_tests/Fence_unittest.cpp new file mode 100644 index 00000000..27596a06 --- /dev/null +++ b/tests/angle_implementation_unit_tests/Fence_unittest.cpp @@ -0,0 +1,162 @@ +// +// 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 "libGLESv2/Fence.h" +#include "libGLESv2/renderer/FenceImpl.h" + +using ::testing::_; +using ::testing::Return; +using ::testing::SetArgumentPointee; + +namespace { + +// +// FenceNV tests +// + +class MockFenceNVImpl : public rx::FenceNVImpl +{ + public: + virtual ~MockFenceNVImpl() { destroy(); } + + MOCK_METHOD0(set, gl::Error()); + MOCK_METHOD2(test, gl::Error(bool, GLboolean *)); + MOCK_METHOD1(finishFence, gl::Error(GLboolean *)); + + MOCK_METHOD0(destroy, void()); +}; + +class FenceNVTest : public testing::Test +{ + protected: + virtual void SetUp() + { + mImpl = new MockFenceNVImpl; + EXPECT_CALL(*mImpl, destroy()); + mFence = new gl::FenceNV(mImpl); + } + + virtual void TearDown() + { + delete mFence; + } + + MockFenceNVImpl *mImpl; + gl::FenceNV* mFence; +}; + +TEST_F(FenceNVTest, DestructionDeletesImpl) +{ + MockFenceNVImpl* impl = new MockFenceNVImpl; + EXPECT_CALL(*impl, destroy()).Times(1).RetiresOnSaturation(); + + gl::FenceNV* fence = new gl::FenceNV(impl); + delete fence; + + // 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(FenceNVTest, SetAndTestBehavior) +{ + EXPECT_CALL(*mImpl, set()) + .WillOnce(Return(gl::Error(GL_NO_ERROR))) + .RetiresOnSaturation(); + EXPECT_EQ(GL_FALSE, mFence->isFence()); + mFence->setFence(GL_ALL_COMPLETED_NV); + EXPECT_EQ(GL_TRUE, mFence->isFence()); + // Fake the behavior of testing the fence before and after it's passed. + EXPECT_CALL(*mImpl, test(_, _)) + .WillOnce(DoAll(SetArgumentPointee<1>(GL_FALSE), + Return(gl::Error(GL_NO_ERROR)))) + .WillOnce(DoAll(SetArgumentPointee<1>(GL_TRUE), + Return(gl::Error(GL_NO_ERROR)))) + .RetiresOnSaturation(); + GLboolean out; + mFence->testFence(&out); + EXPECT_EQ(GL_FALSE, out); + mFence->testFence(&out); + EXPECT_EQ(GL_TRUE, out); +} + +// +// FenceSync tests +// + +class MockFenceSyncImpl : public rx::FenceSyncImpl +{ + public: + virtual ~MockFenceSyncImpl() { destroy(); } + + MOCK_METHOD0(set, gl::Error()); + MOCK_METHOD3(clientWait, gl::Error(GLbitfield, GLuint64, GLenum *)); + MOCK_METHOD2(serverWait, gl::Error(GLbitfield, GLuint64)); + MOCK_METHOD1(getStatus, gl::Error(GLint *)); + + MOCK_METHOD0(destroy, void()); +}; + +class FenceSyncTest : public testing::Test +{ + protected: + virtual void SetUp() + { + mImpl = new MockFenceSyncImpl; + EXPECT_CALL(*mImpl, destroy()); + mFence = new gl::FenceSync(mImpl, 1); + mFence->addRef(); + } + + virtual void TearDown() + { + mFence->release(); + } + + MockFenceSyncImpl *mImpl; + gl::FenceSync* mFence; +}; + +TEST_F(FenceSyncTest, DestructionDeletesImpl) +{ + MockFenceSyncImpl* impl = new MockFenceSyncImpl; + EXPECT_CALL(*impl, destroy()).Times(1).RetiresOnSaturation(); + + gl::FenceSync* fence = new gl::FenceSync(impl, 1); + fence->addRef(); + fence->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(FenceSyncTest, SetAndGetStatusBehavior) +{ + EXPECT_CALL(*mImpl, set()) + .WillOnce(Return(gl::Error(GL_NO_ERROR))) + .RetiresOnSaturation(); + mFence->set(GL_SYNC_GPU_COMMANDS_COMPLETE); + EXPECT_EQ(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<0>(GL_UNSIGNALED), + Return(gl::Error(GL_NO_ERROR)))) + .WillOnce(DoAll(SetArgumentPointee<0>(GL_SIGNALED), + Return(gl::Error(GL_NO_ERROR)))) + .RetiresOnSaturation(); + GLint out; + mFence->getStatus(&out); + EXPECT_EQ(GL_UNSIGNALED, out); + mFence->getStatus(&out); + EXPECT_EQ(GL_SIGNALED, out); +} + +} // namespace -- cgit v1.2.3