X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-Scene.cpp;h=959e5ee548053c7695b99addb8ba63dbe156e224;hb=eacc080fe975c523d722dd17c044652317ddd6e8;hp=a573a0bae57899055d7e1ae8767436fbdc29936d;hpb=3556f826b4ecd9de711de7d9489574885639b5d7;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp index a573a0b..959e5ee 100644 --- a/automated-tests/src/dali/utc-Dali-Scene.cpp +++ b/automated-tests/src/dali/utc-Dali-Scene.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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. @@ -224,6 +224,50 @@ struct KeyEventGeneratedReceivedFunctor KeyEventGeneratedSignalData& signalData; }; +// Stores data that is populated in the WheelEventGeneratedSignal callback and will be read by the TET cases +struct WheelEventGeneratedSignalData +{ + WheelEventGeneratedSignalData() + : functorCalled(false) + { + } + + void Reset() + { + functorCalled = false; + + receivedWheelEvent.Reset(); + } + + bool functorCalled; + WheelEvent receivedWheelEvent; +}; + +// Functor that sets the data when called +struct WheelEventGeneratedReceivedFunctor +{ + WheelEventGeneratedReceivedFunctor(WheelEventGeneratedSignalData& data) + : signalData(data) + { + } + + bool operator()(const WheelEvent& wheelEvent) + { + signalData.functorCalled = true; + signalData.receivedWheelEvent = wheelEvent; + + return true; + } + + bool operator()() + { + signalData.functorCalled = true; + return true; + } + + WheelEventGeneratedSignalData& signalData; +}; + void GenerateTouch(TestApplication& application, PointState::Type state, const Vector2& screenPosition) { Integration::TouchEvent touchEvent; @@ -385,12 +429,26 @@ int UtcDaliSceneGet(void) Dali::Integration::Scene scene = application.GetScene(); - Actor actor = Actor::New(); - DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(actor)); + Actor parent = Actor::New(); + Actor child = Actor::New(); - scene.Add(actor); + parent.Add(child); + + // Should be empty scene + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent)); + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child)); - DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(actor)); + scene.Add(parent); + + // Should return the valid scene + DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(parent)); + DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(child)); + + parent.Unparent(); + + // Should be empty scene + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent)); + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child)); END_TEST; } @@ -958,7 +1016,7 @@ int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void) DALI_TEST_EQUALS(surfaceResized, true, TEST_LOCATION); // Check that the viewport is handled properly - DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams)); + DALI_TEST_CHECK(callStack.FindIndexFromMethodAndParams("Viewport", viewportParams) >= 0); // Check current surface rect newSurfaceRect = defaultScene.GetCurrentSurfaceRect(); @@ -1114,18 +1172,21 @@ int UtcDaliSceneSurfaceRotatedWithAngle0(void) actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); application.GetScene().Add(actor); + // consume the orientating changing flag by first rendering application.SendNotification(); damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 0); + 0, 0); - // Check current surface orientation + // Check current orientations int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1140,11 +1201,13 @@ int UtcDaliSceneSurfaceRotatedWithAngle0(void) DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); END_TEST; } @@ -1185,13 +1248,15 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 90); + 90, 0); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1203,6 +1268,7 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 90, (90 + 0 = 90) clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); clippingRect.y = CLIPPING_RECT_X; clippingRect.width = CLIPPING_RECT_HEIGHT; @@ -1213,18 +1279,20 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle180(void) +int UtcDaliSceneScreenRotatedWithAngle90(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 180"); + tet_infoline("Ensure rotation of the screen is handled properly with Angle 90"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1258,13 +1326,15 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 180); + 0, 90); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1276,28 +1346,31 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); - clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); - clippingRect.width = CLIPPING_RECT_WIDTH; - clippingRect.height = CLIPPING_RECT_HEIGHT; + // Total angle is 90, (0 + 90 = 90) + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. - DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle270(void) +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle90(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 270"); + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 90"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1331,13 +1404,15 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 270); + 90, 90); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1349,28 +1424,31 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = CLIPPING_RECT_Y; - clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); - clippingRect.width = CLIPPING_RECT_HEIGHT; - clippingRect.height = CLIPPING_RECT_WIDTH; + // Total angle is 180.(90 + 90 = 180) + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. - DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); END_TEST; } -int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) +int UtcDaliSceneSurfaceRotatedWithAngle180(void) { - tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton"); + tet_infoline("Ensure rotation of the surface is handled properly with Angle 180"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1388,6 +1466,8 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; application.RenderWithPartialUpdate(damagedRects, clippingRect); Actor actor = CreateRenderableActor(); @@ -1402,15 +1482,15 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 90); + 180, 0); // Check current surface orientation int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should not be changed yet. DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); - - application.GetScene().SetRotationCompletedAcknowledgement(); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); @@ -1422,141 +1502,837 @@ int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); - clippingRect.y = CLIPPING_RECT_X; - clippingRect.width = CLIPPING_RECT_HEIGHT; - clippingRect.height = CLIPPING_RECT_WIDTH; + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Check current surface orientation + // Check current orientations orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); // It should be changed. - DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); - - bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); - DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); END_TEST; } -int UtcDaliSceneKeyEventGeneratedSignalP(void) +int UtcDaliSceneScreenRotatedWithAngle180(void) { - TestApplication application; - Dali::Integration::Scene scene = application.GetScene(); + tet_infoline("Ensure rotation of the screen is handled properly with Angle 180"); - KeyEventGeneratedSignalData data; - KeyEventGeneratedReceivedFunctor functor(data); - scene.KeyEventGeneratedSignal().Connect(&application, functor); + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); - Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event); + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event.state == static_cast(data.receivedKeyEvent.GetState())); + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); - data.Reset(); + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); - Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event2); + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event2.state == static_cast(data.receivedKeyEvent.GetState())); + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); - data.Reset(); + application.SendNotification(); - Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event3); + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 180); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event3.state == static_cast(data.receivedKeyEvent.GetState())); + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); - data.Reset(); + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); - Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event4); + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event4.state == static_cast(data.receivedKeyEvent.GetState())); - END_TEST; -} + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); -int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void) -{ - tet_infoline("Ensure we keep background color when the scene surface is replaced "); + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; - TestApplication application; + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - // Create a new scene and set the background color of the main scene - auto defaultScene = application.GetScene(); - defaultScene.SetBackgroundColor(Color::BLUE); + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); - // Need to create a renderable as we don't start rendering until we have at least one - // We don't need to add this to any scene - auto actor = CreateRenderableActor(); + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); - auto& glAbstraction = application.GetGlAbstraction(); - auto clearCountBefore = glAbstraction.GetClearCountCalled(); + END_TEST; +} - application.SendNotification(); - application.Render(); +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle180(void) +{ + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 180"); - DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION); - DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); - defaultScene.SurfaceReplaced(); + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + std::vector> damagedRects; + Rect clippingRect; application.SendNotification(); - application.Render(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); - DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION); - DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); - // Check when the main render task viewport is set the clear color is clipped using scissors - TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace(); - TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace(); - scissorTrace.Enable(true); - enabledDisableTrace.Enable(true); + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); - defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f)); + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + // consume the orientating changing flag by first rendering application.SendNotification(); - application.Render(); - // Check scissor test was enabled. - std::ostringstream scissor; - scissor << std::hex << GL_SCISSOR_TEST; - DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str())); + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 180, 180); - // Check the scissor was set, and the coordinates are correct. - DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100")); + // Check current orientations + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); - DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION); - DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); - scissorTrace.Enable(false); - scissorTrace.Reset(); + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); - enabledDisableTrace.Enable(false); - enabledDisableTrace.Reset(); + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); - END_TEST; + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the surface is handled properly with Angle 270"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 270, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 270. (270 + 0 = 270) + clippingRect.x = CLIPPING_RECT_Y; + clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneScreenRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the screen is handled properly with Angle 270"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 270); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 270. (0 + 270 = 270) + clippingRect.x = CLIPPING_RECT_Y; + clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 270"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 270, 270); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 180.(270 + 270 - 360 = 180) + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetSurfaceRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 90, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetScreenRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing screen 90 angle rotaiton"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetSurfaceAndScreenRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing surface and screen 90 angle rotaiton"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 90, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceRotatedPartialUpdate(void) +{ + tet_infoline("Ensure rotation of the surface and partial update are handled properly"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + clippingRect = Rect(224, 384, 48, 48); // in screen coordinates + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + damagedRects.clear(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + damagedRects.clear(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // Ensure the damaged rect is empty + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + // Rotate surface + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_SURFACE_WIDTH, + 90, 0); + + damagedRects.clear(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + clippingRect = Rect(224, 224, 208, 208); // in screen coordinates, merged value with the previous rect + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + END_TEST; +} + +int UtcDaliSceneKeyEventGeneratedSignalP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventGeneratedSignalData data; + KeyEventGeneratedReceivedFunctor functor(data); + scene.KeyEventGeneratedSignal().Connect(&application, functor); + + Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event.state == static_cast(data.receivedKeyEvent.GetState())); + + data.Reset(); + + Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event2); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event2.state == static_cast(data.receivedKeyEvent.GetState())); + + data.Reset(); + + Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event3); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event3.state == static_cast(data.receivedKeyEvent.GetState())); + + data.Reset(); + + Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event4); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event4.state == static_cast(data.receivedKeyEvent.GetState())); + END_TEST; +} + +int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void) +{ + tet_infoline("Ensure we keep background color when the scene surface is replaced "); + + TestApplication application; + + // Create a new scene and set the background color of the main scene + auto defaultScene = application.GetScene(); + defaultScene.SetBackgroundColor(Color::BLUE); + + // Need to create a renderable as we don't start rendering until we have at least one + // We don't need to add this to any scene + auto actor = CreateRenderableActor(); + + auto& glAbstraction = application.GetGlAbstraction(); + auto clearCountBefore = glAbstraction.GetClearCountCalled(); + + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION); + DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + + defaultScene.SurfaceReplaced(); + + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION); + DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + + // Check when the main render task viewport is set the clear color is clipped using scissors + TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace(); + TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace(); + scissorTrace.Enable(true); + enabledDisableTrace.Enable(true); + + defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f)); + + application.SendNotification(); + application.Render(); + + // Check scissor test was enabled. + std::ostringstream scissor; + scissor << std::hex << GL_SCISSOR_TEST; + DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str())); + + // Check the scissor was set, and the coordinates are correct. + DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100")); + + DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION); + DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + + scissorTrace.Enable(false); + scissorTrace.Reset(); + + enabledDisableTrace.Enable(false); + enabledDisableTrace.Reset(); + + END_TEST; } int UtcDaliSceneEnsureRenderTargetRecreated(void) @@ -1702,3 +2478,200 @@ int UtcDaliSceneFrameRenderedPresentedCallback(void) END_TEST; } + +int UtcDaliSceneWheelEventGeneratedSignalP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + WheelEventGeneratedSignalData data; + WheelEventGeneratedReceivedFunctor functor(data); + scene.WheelEventGeneratedSignal().Connect(&application, functor); + + Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u); + application.ProcessEvent(event); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(static_cast(event.type) == data.receivedWheelEvent.GetType()); + DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection()); + DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers()); + DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint()); + DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta()); + DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime()); + + data.Reset(); + + Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u); + application.ProcessEvent(event2); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(static_cast(event2.type) == data.receivedWheelEvent.GetType()); + DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection()); + DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers()); + DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint()); + DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta()); + DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime()); + END_TEST; +} + +int UtcDaliSceneSignalInterceptKeyEventP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventSignalData data; + KeyEventReceivedFunctor functor(data); + scene.KeyEventSignal().Connect(&application, functor); + + KeyEventGeneratedSignalData interceptData; + KeyEventGeneratedReceivedFunctor interceptFunctor(interceptData); + scene.InterceptKeyEventSignal().Connect(&application, interceptFunctor); + + Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event2); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event2.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event2.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event2.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event2.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event3); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event3.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event3.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event3.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event3.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event4); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event4.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event4.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event4.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event4.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + END_TEST; +} + +int UtcDaliSceneSignalInterceptKeyEventN(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventGeneratedSignalData data; + KeyEventGeneratedReceivedFunctor functor(data); + scene.InterceptKeyEventSignal().Connect(&application, functor); + + // Check that a non-pressed key events data is not modified. + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneGetOverlayLayer(void) +{ + TestApplication application; + tet_infoline("Testing Dali::Integration::Scene::GetOverlayLayer"); + + Dali::Integration::Scene scene = application.GetScene(); + + // Check we get a valid instance. + RenderTaskList tasks = scene.GetRenderTaskList(); + + // There should be 1 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION); + RenderTask defaultTask = tasks.GetTask(0u); + DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION); + + Layer layer = scene.GetOverlayLayer(); + // There should be 2 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + RenderTask overlayTask = tasks.GetTask(1u); + DALI_TEST_EQUALS(overlayTask, tasks.GetOverlayTask(), TEST_LOCATION); + DALI_TEST_CHECK(scene.GetRootLayer() != overlayTask.GetSourceActor()); + DALI_TEST_CHECK(overlayTask != defaultTask); + DALI_TEST_EQUALS(overlayTask.GetClearEnabled(), false, TEST_LOCATION); + DALI_TEST_EQUALS(overlayTask.IsExclusive(), true, TEST_LOCATION); + + // If new render task is created, the last task is overlayTask + RenderTask newTask = scene.GetRenderTaskList().CreateTask(); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 3u, TEST_LOCATION); + DALI_TEST_EQUALS(newTask, tasks.GetTask(1u), TEST_LOCATION); + DALI_TEST_EQUALS(overlayTask, tasks.GetTask(2u), TEST_LOCATION); + + // Render + application.SendNotification(); + application.Render(); + + tasks.RemoveTask(overlayTask); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + DALI_TEST_EQUALS(tasks.GetTask(0u), defaultTask, TEST_LOCATION); + DALI_TEST_EQUALS(tasks.GetTask(1u), newTask, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceResizedWithOverlayLayer(void) +{ + tet_infoline("Ensure resizing of the surface is handled properly"); + + TestApplication application; + + auto scene = application.GetScene(); + DALI_TEST_CHECK(scene); + + const RenderTaskList& tasks = scene.GetRenderTaskList(); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION); + RenderTask defaultTask = tasks.GetTask(0u); + DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION); + + // Ensure stage size matches the scene size + auto stage = Stage::GetCurrent(); + Vector2 sceneSize = stage.GetSize(); + Viewport sceneViewport(0, 0, sceneSize.x, sceneSize.y); + DALI_TEST_EQUALS(stage.GetSize(), scene.GetSize(), TEST_LOCATION); + Viewport defaultViewport = defaultTask.GetViewport(); + DALI_TEST_EQUALS(defaultViewport, sceneViewport, TEST_LOCATION); + + Layer layer = scene.GetOverlayLayer(); + // There should be 2 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + RenderTask overlayTask = tasks.GetTask(1u); + Viewport overlayViewport = defaultTask.GetViewport(); + DALI_TEST_EQUALS(defaultViewport, overlayViewport, TEST_LOCATION); + + // Resize the scene + Vector2 newSize(1000.0f, 2000.0f); + DALI_TEST_CHECK(stage.GetSize() != newSize); + scene.SurfaceResized(newSize.width, newSize.height); + Viewport newViewport(0, 0, newSize.x, newSize.y); + DALI_TEST_EQUALS(newViewport, defaultTask.GetViewport(), TEST_LOCATION); + DALI_TEST_EQUALS(newViewport, defaultTask.GetViewport(), TEST_LOCATION); + + END_TEST; +}