${TEST_HARNESS_DIR}/test-harness.cpp
${TEST_HARNESS_DIR}/test-gesture-generator.cpp
${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
- ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-sync-impl.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-sync-object.cpp
${TEST_HARNESS_DIR}/test-graphics-buffer.cpp
${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
${TEST_HARNESS_DIR}/test-graphics-controller.cpp
${TEST_HARNESS_DIR}/test-harness.cpp
${TEST_HARNESS_DIR}/test-gesture-generator.cpp
${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
- ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-sync-impl.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-sync-object.cpp
${TEST_HARNESS_DIR}/test-graphics-buffer.cpp
${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
${TEST_HARNESS_DIR}/test-graphics-framebuffer.cpp
${TEST_HARNESS_DIR}/test-harness.cpp
${TEST_HARNESS_DIR}/test-gesture-generator.cpp
${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
- ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-sync-impl.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-sync-object.cpp
${TEST_HARNESS_DIR}/test-graphics-buffer.cpp
${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
${TEST_HARNESS_DIR}/test-graphics-controller.cpp
ALL
COMMAND ${SHADER_GENERATOR} ${SHADER_FOLDER} ${GENERATED_FOLDER} | grep "SHADER_SHADER_DEFINE_DEF" | grep "shader-define-def.h" > /dev/null 2>&1 && echo "test_def_correct Succeeded"
VERBATIM)
-
../dali-toolkit/dali-toolkit-test-utils/test-button.cpp
../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
- ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-sync-impl.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-sync-object.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
../dali-toolkit/dali-toolkit-test-utils/test-application.cpp
../dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp
../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
- ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-sync-impl.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-sync-object.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
../dali-toolkit/dali-toolkit-test-utils/test-button.cpp
../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp
- ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-sync-impl.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/test-graphics-sync-object.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp
../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp
dali-toolkit-test-utils/test-harness.cpp
dali-toolkit-test-utils/test-gesture-generator.cpp
dali-toolkit-test-utils/test-gl-abstraction.cpp
- dali-toolkit-test-utils/test-gl-sync-abstraction.cpp
+ dali-toolkit-test-utils/test-graphics-sync-impl.cpp
+ dali-toolkit-test-utils/test-graphics-sync-object.cpp
dali-toolkit-test-utils/test-graphics-buffer.cpp
dali-toolkit-test-utils/test-graphics-command-buffer.cpp
dali-toolkit-test-utils/test-graphics-controller.cpp
return static_cast<TestGlAbstraction&>(mGraphicsController.GetGlAbstraction());
}
-TestGlSyncAbstraction& TestApplication::GetGlSyncAbstraction()
+TestGlContextHelperAbstraction& TestApplication::GetGlContextHelperAbstraction()
{
- return static_cast<TestGlSyncAbstraction&>(mGraphicsController.GetGlSyncAbstraction());
+ return static_cast<TestGlContextHelperAbstraction&>(mGraphicsController.GetGlContextHelperAbstraction());
}
-TestGlContextHelperAbstraction& TestApplication::GetGlContextHelperAbstraction()
+TestGraphicsSyncImplementation& TestApplication::GetGraphicsSyncImpl()
{
- return static_cast<TestGlContextHelperAbstraction&>(mGraphicsController.GetGlContextHelperAbstraction());
+ return static_cast<TestGraphicsSyncImplementation&>(mGraphicsController.GetGraphicsSyncImpl());
}
void TestApplication::ProcessEvent(const Integration::Event& event)
TestGraphicsController& GetGraphicsController();
TestGlAbstraction& GetGlAbstraction();
- TestGlSyncAbstraction& GetGlSyncAbstraction();
TestGlContextHelperAbstraction& GetGlContextHelperAbstraction();
+ TestGraphicsSyncImplementation& GetGraphicsSyncImpl();
void ProcessEvent(const Integration::Event& event);
void SendNotification();
+++ /dev/null
-/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "test-gl-sync-abstraction.h"
-
-namespace Dali
-{
-TestSyncObject::TestSyncObject(TraceCallStack& trace)
-: synced(false),
- mTrace(trace)
-{
-}
-
-TestSyncObject::~TestSyncObject()
-{
-}
-
-bool TestSyncObject::IsSynced()
-{
- mTrace.PushCall("SyncObject::IsSynced", ""); // Trace the method
- return synced;
-}
-
-TestGlSyncAbstraction::TestGlSyncAbstraction()
-{
- Initialize();
-}
-
-/**
- * Destructor
- */
-TestGlSyncAbstraction::~TestGlSyncAbstraction()
-{
- for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
- {
- delete *iter;
- }
-}
-
-/**
- * Initialize the sync objects - clear down the map
- */
-void TestGlSyncAbstraction::Initialize()
-{
- mSyncObjects.clear();
-}
-
-/**
- * Create a sync object
- * @return the sync object
- */
-Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::CreateSyncObject()
-{
- mTrace.PushCall("CreateSyncObject", ""); // Trace the method
-
- TestSyncObject* syncObject = new TestSyncObject(mTrace);
- mSyncObjects.push_back(syncObject);
- return syncObject;
-}
-
-/**
- * Destroy a sync object
- * @param[in] syncObject The object to destroy
- */
-void TestGlSyncAbstraction::DestroySyncObject(Integration::GlSyncAbstraction::SyncObject* syncObject)
-{
- std::stringstream out;
- out << syncObject;
- mTrace.PushCall("DestroySyncObject", out.str()); // Trace the method
-
- for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
- {
- if(*iter == syncObject)
- {
- delete *iter;
- mSyncObjects.erase(iter);
- break;
- }
- }
-}
-
-Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::GetLastSyncObject()
-{
- if(!mSyncObjects.empty())
- {
- return mSyncObjects.back();
- }
- return NULL;
-}
-
-/**
- * Test method to trigger the object sync behaviour.
- * @param[in]
- * @param[in] sync The sync value to set
- */
-void TestGlSyncAbstraction::SetObjectSynced(Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync)
-{
- TestSyncObject* testSyncObject = static_cast<TestSyncObject*>(syncObject);
- testSyncObject->synced = sync;
-}
-
-/**
- * Turn trace on
- */
-void TestGlSyncAbstraction::EnableTrace(bool enable)
-{
- mTrace.Enable(enable);
-}
-
-/**
- * Reset the trace callstack
- */
-void TestGlSyncAbstraction::ResetTrace()
-{
- mTrace.Reset();
-}
-
-/**
- * Get the trace object (allows test case to find methods on it)
- */
-TraceCallStack& TestGlSyncAbstraction::GetTrace()
-{
- return mTrace;
-}
-
-int32_t TestGlSyncAbstraction::GetNumberOfSyncObjects()
-{
- return static_cast<int32_t>(mSyncObjects.size());
-}
-
-} // namespace Dali
+++ /dev/null
-#ifndef TEST_GL_SYNC_ABSTRACTION_H
-#define TEST_GL_SYNC_ABSTRACTION_H
-
-/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// EXTERNAL INCLUDES
-#include <map>
-#include <sstream>
-#include <string>
-
-// INTERNAL INCLUDES
-#include <dali/integration-api/core.h>
-#include <dali/integration-api/gl-sync-abstraction.h>
-
-#include "test-trace-call-stack.h"
-
-namespace Dali
-{
-class DALI_CORE_API TestSyncObject : public Integration::GlSyncAbstraction::SyncObject
-{
-public:
- TestSyncObject(TraceCallStack& trace);
- ~TestSyncObject() override;
- bool IsSynced() override;
- bool synced;
- TraceCallStack& mTrace;
-};
-
-/**
- * Class to emulate the GL sync functions with tracing
- */
-class DALI_CORE_API TestGlSyncAbstraction : public Integration::GlSyncAbstraction
-{
-public:
- /**
- * Constructor
- */
- TestGlSyncAbstraction();
-
- /**
- * Destructor
- */
- ~TestGlSyncAbstraction() override;
-
- /**
- * Initialize the sync objects - clear down the map
- */
- void Initialize();
-
- /**
- * Create a sync object
- * @return the sync object
- */
- Integration::GlSyncAbstraction::SyncObject* CreateSyncObject() override;
-
- /**
- * Destroy a sync object
- * @param[in] syncObject The object to destroy
- */
- void DestroySyncObject(Integration::GlSyncAbstraction::SyncObject* syncObject) override;
-
-public: // TEST FUNCTIONS
- Integration::GlSyncAbstraction::SyncObject* GetLastSyncObject();
-
- /**
- * Test method to trigger the object sync behaviour.
- * @param[in]
- * @param[in] sync The sync value to set
- */
- void SetObjectSynced(Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync);
-
- /**
- * Turn trace on
- */
- void EnableTrace(bool enable);
-
- /**
- * Reset the trace callstack
- */
- void ResetTrace();
-
- /**
- * Get the trace object (allows test case to find methods on it)
- */
- TraceCallStack& GetTrace();
-
- /**
- * Get the number of sync objects
- *
- * @return the number of sync objects
- */
- int32_t GetNumberOfSyncObjects();
-
-private:
- TestGlSyncAbstraction(const TestGlSyncAbstraction&); ///< Undefined
- TestGlSyncAbstraction& operator=(const TestGlSyncAbstraction&); ///< Undefined
-
- typedef std::vector<TestSyncObject*> SyncContainer;
- typedef SyncContainer::iterator SyncIter;
- SyncContainer mSyncObjects; ///< The sync objects
- TraceCallStack mTrace{true, "gl"}; ///< the trace call stack for testing
-};
-
-} // namespace Dali
-
-#endif // TEST_GL_SYNC_ABSTRACTION_H
struct
{
+ Graphics::SyncObject* syncObject;
} endRenderPass;
struct
* dependencies (for example, to know when target texture is ready
* before passing it to another render pass).
*/
- void EndRenderPass() override
+ void EndRenderPass(Graphics::SyncObject* syncObject) override
{
- mCallStack.PushCall("EndRenderPass", "");
+ mCommands.emplace_back(CommandType::END_RENDER_PASS);
+ auto& cmd = mCommands.back();
+
+ cmd.data.endRenderPass.syncObject = syncObject;
+
+ TraceCallStack::NamedParams namedParams;
+ namedParams["syncObject"] << std::hex << syncObject;
+ mCallStack.PushCall("EndRenderPass", namedParams.str(), namedParams);
}
void ExecuteCommandBuffers(std::vector<const CommandBuffer*>&& commandBuffers) override
#include "test-graphics-render-target.h"
#include "test-graphics-sampler.h"
#include "test-graphics-shader.h"
+#include "test-graphics-sync-object.h"
#include "test-graphics-texture.h"
#include <dali/integration-api/gl-defines.h>
}
case CommandType::END_RENDER_PASS:
{
+ if(cmd.data.endRenderPass.syncObject != nullptr)
+ {
+ auto syncObject = Uncast<TestGraphicsSyncObject>(cmd.data.endRenderPass.syncObject);
+ syncObject->InitializeResource(); // create the sync object.
+ }
break;
}
}
return Graphics::MakeUnique<TestGraphicsRenderTarget>(mGl, renderTargetCreateInfo);
}
+Graphics::UniquePtr<Graphics::SyncObject> TestGraphicsController::CreateSyncObject(
+ const Graphics::SyncObjectCreateInfo& syncObjectCreateInfo,
+ Graphics::UniquePtr<Graphics::SyncObject>&& oldSyncObject)
+{
+ mCallStack.PushCall("CreateSyncObject", "");
+ return Graphics::MakeUnique<TestGraphicsSyncObject>(mGraphicsSyncImpl, syncObjectCreateInfo);
+}
+
Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
{
mCallStack.PushCall("MapBufferRange", "");
#include <dali/graphics-api/graphics-controller.h>
#include "test-gl-abstraction.h"
#include "test-gl-context-helper-abstraction.h"
-#include "test-gl-sync-abstraction.h"
#include "test-graphics-command-buffer.h"
#include "test-graphics-program.h"
#include "test-graphics-reflection.h"
+#include "test-graphics-sync-impl.h"
namespace Dali
{
return const_cast<T*>(static_cast<const T*>(object));
}
+template<typename T>
+T* Uncast(const Graphics::SyncObject* object)
+{
+ return const_cast<T*>(static_cast<const T*>(object));
+}
+
class TestGraphicsController : public Dali::Graphics::Controller
{
public:
return mGl;
}
- Integration::GlSyncAbstraction& GetGlSyncAbstraction() override
+ Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override
{
- return mGlSyncAbstraction;
+ return mGlContextHelperAbstraction;
}
- Integration::GlContextHelperAbstraction& GetGlContextHelperAbstraction() override
+ TestGraphicsSyncImplementation& GetGraphicsSyncImpl()
{
- return mGlContextHelperAbstraction;
+ return mGraphicsSyncImpl;
}
void SubmitCommandBuffers(const Graphics::SubmitInfo& submitInfo) override;
*/
Graphics::UniquePtr<Graphics::RenderTarget> CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget) override;
+ /**
+ * @brief Creates new sync object
+ * Could add timeout etc to createinfo... but nah.
+ *
+ * @return pointer to the SyncObject
+ */
+ Graphics::UniquePtr<Graphics::SyncObject> CreateSyncObject(const Graphics::SyncObjectCreateInfo& syncObjectCreateInfo,
+ Graphics::UniquePtr<Graphics::SyncObject>&& oldSyncObject) override;
+
/**
* @brief Maps memory associated with Buffer object
*
* @param[in] mapInfo Filled details of mapped resource
*
- * @return Returns pointer to Memory object or Graphicsnullptr on error
+ * @return Returns pointer to Memory object or nullptr on error
*/
Graphics::UniquePtr<Graphics::Memory> MapBufferRange(const Graphics::MapBufferInfo& mapInfo) override;
mutable std::vector<Graphics::SubmitInfo> mSubmitStack;
TestGlAbstraction mGl;
- TestGlSyncAbstraction mGlSyncAbstraction;
+ TestGraphicsSyncImplementation mGraphicsSyncImpl;
TestGlContextHelperAbstraction mGlContextHelperAbstraction;
bool isDiscardQueueEmptyResult{true};
--- /dev/null
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "test-graphics-sync-impl.h"
+
+namespace Dali
+{
+TestSyncObject::TestSyncObject(Dali::TraceCallStack& trace)
+
+: synced(false),
+ mTrace(trace)
+{
+ mTrace.PushCall("TestSyncObject cons", ""); // Trace the method
+}
+
+TestSyncObject::~TestSyncObject()
+{
+ mTrace.PushCall("TestSyncObject dstr", ""); // Trace the method
+}
+
+bool TestSyncObject::IsSynced()
+{
+ mTrace.PushCall("SyncObject::IsSynced", ""); // Trace the method
+ return synced;
+}
+
+TestGraphicsSyncImplementation::TestGraphicsSyncImplementation()
+{
+ Initialize();
+}
+
+/**
+ * Destructor
+ */
+TestGraphicsSyncImplementation::~TestGraphicsSyncImplementation()
+{
+ for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
+ {
+ delete *iter;
+ }
+}
+
+/**
+ * Initialize the sync objects
+ */
+void TestGraphicsSyncImplementation::Initialize()
+{
+ mSyncObjects.clear();
+}
+
+Integration::GraphicsSyncAbstraction::SyncObject* TestGraphicsSyncImplementation::CreateSyncObject()
+{
+ mTrace.PushCall("CreateSyncObject", ""); // Trace the method
+
+ TestSyncObject* syncObject = new TestSyncObject(mTrace);
+ mSyncObjects.push_back(syncObject);
+ return syncObject;
+}
+
+/**
+ * Destroy a sync object
+ * @param[in] syncObject The object to destroy
+ */
+void TestGraphicsSyncImplementation::DestroySyncObject(Integration::GraphicsSyncAbstraction::SyncObject* syncObject)
+{
+ std::stringstream out;
+ out << syncObject;
+ mTrace.PushCall("DestroySyncObject", out.str()); // Trace the method
+
+ for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
+ {
+ if(*iter == syncObject)
+ {
+ delete *iter;
+ mSyncObjects.erase(iter);
+ break;
+ }
+ }
+}
+
+Integration::GraphicsSyncAbstraction::SyncObject* TestGraphicsSyncImplementation::GetLastSyncObject()
+{
+ if(!mSyncObjects.empty())
+ {
+ return mSyncObjects.back();
+ }
+ return NULL;
+}
+
+/**
+ * Test method to trigger the object sync behaviour.
+ * @param[in]
+ * @param[in] sync The sync value to set
+ */
+void TestGraphicsSyncImplementation::SetObjectSynced(Integration::GraphicsSyncAbstraction::SyncObject* syncObject, bool sync)
+{
+ TestSyncObject* testSyncObject = static_cast<TestSyncObject*>(syncObject);
+ testSyncObject->synced = sync;
+}
+
+/**
+ * Turn trace on
+ */
+void TestGraphicsSyncImplementation::EnableTrace(bool enable)
+{
+ mTrace.Enable(enable);
+}
+
+/**
+ * Reset the trace callstack
+ */
+void TestGraphicsSyncImplementation::ResetTrace()
+{
+ mTrace.Reset();
+}
+
+/**
+ * Get the trace object (allows test case to find methods on it)
+ */
+TraceCallStack& TestGraphicsSyncImplementation::GetTrace()
+{
+ return mTrace;
+}
+
+int32_t TestGraphicsSyncImplementation::GetNumberOfSyncObjects()
+{
+ return static_cast<int32_t>(mSyncObjects.size());
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef TEST_SYNC_IMPLEMENTATION_H
+#define TEST_SYNC_IMPLEMENTATION_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <map>
+#include <sstream>
+#include <string>
+
+// INTERNAL INCLUDES
+#include <dali/graphics-api/graphics-sync-object-create-info.h>
+#include <dali/graphics-api/graphics-sync-object.h>
+#include <dali/integration-api/core.h>
+#include <dali/integration-api/graphics-sync-abstraction.h>
+
+#include "test-trace-call-stack.h"
+
+namespace Dali
+{
+class TestGraphicsSyncImplementation;
+
+class TestSyncObject : public Integration::GraphicsSyncAbstraction::SyncObject
+{
+public:
+ TestSyncObject(TraceCallStack& trace);
+ ~TestSyncObject() override;
+ bool IsSynced() override;
+ bool synced;
+ TraceCallStack& mTrace;
+};
+
+/**
+ * Class to emulate the gpu sync functions with tracing
+ */
+class TestGraphicsSyncImplementation : public Integration::GraphicsSyncAbstraction
+{
+public:
+ /**
+ * Constructor
+ */
+ TestGraphicsSyncImplementation();
+
+ /**
+ * Destructor
+ */
+ virtual ~TestGraphicsSyncImplementation();
+
+ /**
+ * Initialize the sync objects
+ */
+ void Initialize();
+
+ /**
+ * Create a sync object that can be polled
+ */
+ GraphicsSyncAbstraction::SyncObject* CreateSyncObject() override;
+
+ /**
+ * Destroy a sync object
+ */
+ void DestroySyncObject(GraphicsSyncAbstraction::SyncObject* syncObject) override;
+
+public: // TEST FUNCTIONS
+ GraphicsSyncAbstraction::SyncObject* GetLastSyncObject();
+
+ /**
+ * Test method to trigger the object sync behaviour.
+ * @param[in]
+ * @param[in] sync The sync value to set
+ */
+ void SetObjectSynced(GraphicsSyncAbstraction::SyncObject* syncObject, bool sync);
+
+ /**
+ * Turn trace on
+ */
+ void EnableTrace(bool enable);
+
+ /**
+ * Reset the trace callstack
+ */
+ void ResetTrace();
+
+ /**
+ * Get the trace object (allows test case to find methods on it)
+ */
+ TraceCallStack& GetTrace();
+
+ /**
+ * Get the number of sync objects
+ *
+ * @return the number of sync objects
+ */
+ int32_t GetNumberOfSyncObjects();
+
+ TestGraphicsSyncImplementation(const TestGraphicsSyncImplementation&) = delete;
+ TestGraphicsSyncImplementation& operator=(const TestGraphicsSyncImplementation&) = delete;
+
+private:
+ typedef std::vector<TestSyncObject*> SyncContainer;
+ typedef SyncContainer::iterator SyncIter;
+ SyncContainer mSyncObjects; ///< The sync objects
+ TraceCallStack mTrace{true, "gl"}; ///< the trace call stack for testing
+};
+
+} // namespace Dali
+
+#endif // TEST_GL_SYNC_ABSTRACTION_H
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "test-graphics-sync-object.h"
+
+namespace Dali
+{
+TestGraphicsSyncObject::TestGraphicsSyncObject(TestGraphicsSyncImplementation& syncImpl, const Graphics::SyncObjectCreateInfo& createInfo)
+: mSyncImplementation(syncImpl),
+ mSyncObject(nullptr),
+ mCreateInfo(createInfo)
+{
+}
+
+TestGraphicsSyncObject::~TestGraphicsSyncObject()
+{
+ mSyncImplementation.DestroySyncObject(mSyncObject);
+}
+
+void TestGraphicsSyncObject::InitializeResource()
+{
+ mSyncObject = static_cast<TestSyncObject*>(mSyncImplementation.CreateSyncObject());
+}
+
+bool TestGraphicsSyncObject::IsSynced()
+{
+ bool synced = false;
+ if(mSyncObject)
+ {
+ synced = mSyncObject->IsSynced();
+ }
+ return synced;
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TEST_GRAPHICS_SYNC_OBJECT_H_
+#define DALI_TEST_GRAPHICS_SYNC_OBJECT_H_
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/graphics-api/graphics-sync-object-create-info.h>
+#include <dali/graphics-api/graphics-sync-object.h>
+
+#include <test-graphics-sync-impl.h>
+
+namespace Dali
+{
+class TestGraphicsSyncObject : public Graphics::SyncObject
+{
+public:
+ TestGraphicsSyncObject(TestGraphicsSyncImplementation& syncImpl, const Graphics::SyncObjectCreateInfo& createInfo);
+ ~TestGraphicsSyncObject() override;
+ void InitializeResource();
+ bool IsSynced() override;
+
+public:
+ TestGraphicsSyncImplementation& mSyncImplementation;
+ TestSyncObject* mSyncObject;
+ Graphics::SyncObjectCreateInfo mCreateInfo;
+};
+
+} // namespace Dali
+
+#endif //DALI_TEST_GRAPHICS_SYNC_OBJECT_H
projects / platform / core / uifw / dali-toolkit.git / commitdiff