X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Ftoolkit-adaptor.cpp;h=5dbbe764d21b833fdcd2cbf7a1762bebe3d06f0f;hp=9071613c2ea7feb6efec78f944b52f888a02726f;hb=HEAD;hpb=b3636da16f13873c444b913df7bc6acf5b9dacb8 diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp index 9071613..40c73ae 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019 Samsung Electronics Co., Ltd. + * Copyright (c) 2024 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. @@ -17,52 +17,29 @@ #include -#include +#include // Don't want to include the actual window.h which otherwise will be indirectly included by adaptor.h. #define DALI_WINDOW_H -#include +#include +#include -#include - -#include #include #include #include -#include +#include +#include +#include +#include +#include +#include "dali-test-suite-utils.h" namespace Dali { - -namespace -{ - -/////////////////////////////////////////////////////////////////////////////// -// -// LogFactoryStub -// -/////////////////////////////////////////////////////////////////////////////// - -class LogFactory : public LogFactoryInterface -{ -public: - LogFactory() = default; - virtual ~LogFactory() = default; - -private: - void InstallLogFunction() const override - { - Dali::Integration::Log::InstallLogFunction( &TestApplication::LogMessage ); - } -}; -LogFactory* gLogFactory = NULL; // For some reason, destroying this when the Adaptor is destroyed causes a crash in some test cases when running all of them. -} //unnamed namespace - namespace Internal { namespace Adaptor { - /////////////////////////////////////////////////////////////////////////////// // // Dali::Internal::Adaptor::Adaptor Stub @@ -73,14 +50,14 @@ Dali::Adaptor* gAdaptor = nullptr; Dali::Adaptor& Adaptor::New() { - DALI_ASSERT_ALWAYS( ! gAdaptor ); + DALI_ASSERT_ALWAYS(!gAdaptor); gAdaptor = new Dali::Adaptor; return *gAdaptor; } Dali::Adaptor& Adaptor::Get() { - DALI_ASSERT_ALWAYS( gAdaptor ); + DALI_ASSERT_ALWAYS(gAdaptor); return *gAdaptor; } @@ -91,54 +68,178 @@ Adaptor::Adaptor() Adaptor::~Adaptor() { gAdaptor = nullptr; + + // Ensure all threads and not-excuted tasks are destroyed. + // TODO : we'd better make some singletone service for toolkit UTC in future. + Test::AsyncTaskManager::DestroyAsyncTaskManager(); } -void Adaptor::Start( Dali::Window window ) +void Adaptor::Start(Dali::Window window) { - if ( window ) + AddWindow(&GetImplementation(window)); +} + +void Adaptor::Stop() +{ + if(mTestApplication) { - mWindows.push_back( window ); - mWindowCreatedSignal.Emit( window ); + Integration::Core& core = mTestApplication->GetCore(); + tet_printf("Adaptor::UnregisterProcessors\n"); + core.UnregisterProcessors(); } + + mStopped = true; } -Integration::Scene Adaptor::GetScene( Dali::Window window ) +Integration::Scene Adaptor::GetScene(Dali::Window window) { return window.GetScene(); } -bool Adaptor::AddIdle( CallbackBase* callback, bool hasReturnValue ) +bool Adaptor::AddIdle(CallbackBase* callback, bool hasReturnValue) { - mCallbacks.PushBack( callback ); - return true; + if(ToolkitApplication::ADD_IDLE_SUCCESS) + { + if(hasReturnValue) + { + mReturnCallbacks.PushBack(callback); + } + else + { + mCallbacks.PushBack(callback); + } + } + return ToolkitApplication::ADD_IDLE_SUCCESS; } -void Adaptor::RemoveIdle( CallbackBase* callback ) +void Adaptor::RemoveIdle(CallbackBase* callback) { - mCallbacks.Erase( std::find_if( mCallbacks.Begin(), mCallbacks.End(), - [ &callback ] ( CallbackBase* current ) { return callback == current; } ) ); + mCallbacks.Erase(std::remove_if(mCallbacks.Begin(), mCallbacks.End(), [&callback](CallbackBase* current) { return callback == current; }), mCallbacks.End()); + mReturnCallbacks.Erase(std::remove_if(mReturnCallbacks.Begin(), mReturnCallbacks.End(), [&callback](CallbackBase* current) { return callback == current; }), mReturnCallbacks.End()); } void Adaptor::RunIdles() { - for( auto& callback : mCallbacks ) + Dali::Vector reusedCallbacks; + for(auto& callback : mReturnCallbacks) { - CallbackBase::Execute( *callback ); + bool retValue = CallbackBase::ExecuteReturn(*callback); + if(retValue) + { + reusedCallbacks.PushBack(callback); + } + } + for(auto& callback : mCallbacks) + { + CallbackBase::Execute(*callback); } mCallbacks.Clear(); + mReturnCallbacks.Clear(); + mReturnCallbacks.Swap(reusedCallbacks); +} + +void Adaptor::RequestUpdateOnce() +{ + if(mTestApplication) + { + auto scene = mTestApplication->GetScene(); + if(scene) + { + tet_printf("Adaptor::RequestUpdateOnce()\n"); + scene.KeepRendering(0.0f); + } + } } Dali::RenderSurfaceInterface& Adaptor::GetSurface() { - DALI_ASSERT_ALWAYS( ! mWindows.empty() ); + DALI_ASSERT_ALWAYS(!mWindows.empty()); - return reinterpret_cast < Dali::RenderSurfaceInterface& >( mWindows.front().GetRenderSurface() ); + return reinterpret_cast(mWindows.front()->GetRenderSurface()); } Dali::WindowContainer Adaptor::GetWindows() { - return mWindows; + Dali::WindowContainer windows; + + for(auto iter = mWindows.begin(); iter != mWindows.end(); ++iter) + { + // Downcast to Dali::Window + Dali::Window window(dynamic_cast(*iter)); + if(window) + { + windows.push_back(window); + } + } + + return windows; +} + +Dali::SceneHolderList Adaptor::GetSceneHolders() +{ + Dali::SceneHolderList sceneHolderList; + + for(auto iter = mWindows.begin(); iter != mWindows.end(); ++iter) + { + sceneHolderList.push_back(Dali::Integration::SceneHolder(*iter)); + } + + return sceneHolderList; +} + +Dali::Internal::Adaptor::SceneHolder* Adaptor::GetWindow(Dali::Actor& actor) +{ + Dali::Integration::Scene scene = Dali::Integration::Scene::Get(actor); + + for(auto window : mWindows) + { + if(scene == window->GetScene()) + { + return window; + } + } + + return nullptr; +} + +void Adaptor::AddWindow(Internal::Adaptor::SceneHolder* window) +{ + if(window) + { + mWindows.push_back(window); + + Dali::Integration::SceneHolder newWindow(window); + mWindowCreatedSignal.Emit(newWindow); + } +} + +void Adaptor::RemoveWindow(Internal::Adaptor::SceneHolder* window) +{ + auto iter = std::find(mWindows.begin(), mWindows.end(), window); + if(iter != mWindows.end()) + { + mWindows.erase(iter); + } +} + +void Adaptor::RegisterProcessor(Integration::Processor& processor, bool postProcessor) +{ + Integration::Core& core = mTestApplication->GetCore(); + tet_printf("Adaptor::RegisterProcessor : %s\n", processor.GetProcessorName().data()); + core.RegisterProcessor(processor, postProcessor); +} + +void Adaptor::UnregisterProcessor(Integration::Processor& processor, bool postProcessor) +{ + Integration::Core& core = mTestApplication->GetCore(); + tet_printf("Adaptor::UnregisterProcessor : %s\n", processor.GetProcessorName().data()); + core.UnregisterProcessor(processor, postProcessor); +} + +void Adaptor::SetApplication(Dali::TestApplication& testApplication) +{ + mTestApplication = &testApplication; } Dali::Adaptor::AdaptorSignalType& Adaptor::ResizedSignal() @@ -166,7 +267,7 @@ Dali::Adaptor::WindowCreatedSignalType& Adaptor::WindowCreatedSignal() /////////////////////////////////////////////////////////////////////////////// Adaptor::Adaptor() -: mImpl( new Internal::Adaptor::Adaptor ) +: mImpl(new Internal::Adaptor::Adaptor) { } @@ -190,23 +291,24 @@ void Adaptor::Resume() void Adaptor::Stop() { + mImpl->Stop(); } -bool Adaptor::AddIdle( CallbackBase* callback, bool hasReturnValue ) +bool Adaptor::AddIdle(CallbackBase* callback, bool hasReturnValue) { - return mImpl->AddIdle( callback, hasReturnValue ); + return mImpl->AddIdle(callback, hasReturnValue); } -void Adaptor::RemoveIdle( CallbackBase* callback ) +void Adaptor::RemoveIdle(CallbackBase* callback) { - mImpl->RemoveIdle( callback ); + mImpl->RemoveIdle(callback); } -void Adaptor::ReplaceSurface( Window window, Dali::RenderSurfaceInterface& surface ) +void Adaptor::ReplaceSurface(Window window, Dali::RenderSurfaceInterface& surface) { } -void Adaptor::ReplaceSurface( Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& surface ) +void Adaptor::ReplaceSurface(Dali::Integration::SceneHolder window, Dali::RenderSurfaceInterface& surface) { } @@ -235,13 +337,18 @@ Dali::WindowContainer Adaptor::GetWindows() const return mImpl->GetWindows(); } +Dali::SceneHolderList Adaptor::GetSceneHolders() const +{ + return mImpl->GetSceneHolders(); +} + Any Adaptor::GetNativeWindowHandle() { Any window; return window; } -Any Adaptor::GetNativeWindowHandle( Actor actor ) +Any Adaptor::GetNativeWindowHandle(Actor actor) { return GetNativeWindowHandle(); } @@ -250,7 +357,7 @@ void Adaptor::ReleaseSurfaceLock() { } -void Adaptor::SetRenderRefreshRate( unsigned int numberOfVSyncsPerRender ) +void Adaptor::SetRenderRefreshRate(unsigned int numberOfVSyncsPerRender) { } @@ -261,7 +368,7 @@ Adaptor& Adaptor::Get() bool Adaptor::IsAvailable() { - return Internal::Adaptor::gAdaptor; + return Internal::Adaptor::gAdaptor && (!Internal::Adaptor::Adaptor::GetImpl(*Internal::Adaptor::gAdaptor).IsStopped()); } void Adaptor::NotifySceneCreated() @@ -272,15 +379,15 @@ void Adaptor::NotifyLanguageChanged() { } -void Adaptor::FeedTouchPoint( TouchPoint& point, int timeStamp ) +void Adaptor::FeedTouchPoint(TouchPoint& point, int timeStamp) { } -void Adaptor::FeedWheelEvent( WheelEvent& wheelEvent ) +void Adaptor::FeedWheelEvent(WheelEvent& wheelEvent) { } -void Adaptor::FeedKeyEvent( KeyEvent& keyEvent ) +void Adaptor::FeedKeyEvent(KeyEvent& keyEvent) { } @@ -288,13 +395,68 @@ void Adaptor::SceneCreated() { } +class LogFactory : public LogFactoryInterface +{ +public: + virtual void InstallLogFunction() const + { + Dali::Integration::Log::LogFunction logFunction(&ToolkitTestApplication::LogMessage); + Dali::Integration::Log::InstallLogFunction(logFunction); + } + + LogFactory() + { + } + virtual ~LogFactory() + { + } +}; + +LogFactory* gLogFactory = NULL; const LogFactoryInterface& Adaptor::GetLogFactory() { - if( gLogFactory == NULL ) + if(gLogFactory == NULL) { gLogFactory = new LogFactory; } return *gLogFactory; } +class TraceFactory : public TraceFactoryInterface +{ +public: + virtual void InstallTraceFunction() const + { + Dali::Integration::Trace::LogContextFunction logContextFunction(&TestApplication::LogContext); + Dali::Integration::Trace::InstallLogContextFunction(logContextFunction); + } + + TraceFactory() + { + } + virtual ~TraceFactory() + { + } +}; + +TraceFactory* gTraceFactory = NULL; +const TraceFactoryInterface& Adaptor::GetTraceFactory() +{ + if(gTraceFactory == NULL) + { + gTraceFactory = new TraceFactory; + } + return *gTraceFactory; +} + +void Adaptor::RegisterProcessor(Integration::Processor& processor, bool postProcessor) +{ + mImpl->RegisterProcessor(processor, postProcessor); +} + +void Adaptor::UnregisterProcessor(Integration::Processor& processor, bool postProcessor) +{ + mImpl->UnregisterProcessor(processor, postProcessor); +} + } // namespace Dali