Merge changes I2df640e0,Ia1188305,I7fae506e,I7967a7cc,Ib0fdcdf4, ... into devel/master
authorDavid Steele <david.steele@samsung.com>
Fri, 30 Oct 2020 13:19:09 +0000 (13:19 +0000)
committerGerrit Code Review <gerrit@review>
Fri, 30 Oct 2020 13:19:09 +0000 (13:19 +0000)
* changes:
  [AT-SPI] MERGING MARKER
  [AT-SPI] Correct VISIBLE and SHOWING states
  [AT-SPI] Windows fixes
  [AT-SPI] Fixed uint underflow risk
  [AT-SPI] Guard added for potential null pointer dereference
  [AT-SPI] Implemented reading popup description
  [AT-SPI] Improving utc coverage ToggleButton tests
  [AT-SPI] More coverage
  [AT-SPI] Improving utc coverage
  [AT-SPI] Set both ScreenReaderEnabled and IsEnabled in TestEnableSC
  [AT-SPI] Rewritten UtcDaliControlAccessibilityModal
  [AT-SPI] Pass correct object to dynamic_cast
  [AT-SPI] UTC correction
  [AT-SPI] More UTC fixes
  [AT-SPI] Execute tct under dbus-launch
  [AT-SPI] UTC fixes
  [AT-SPI] Add TestDBusWrapper and bypass compilation problems
  [AT-SPI] Implement accessibility for Popup
  [AT-SPI] Fix cmake cmp0004 error
  [AT-SPI] Catch exception by reference
  [AT-SPI] Migrate Accessibility tests to dali-toolkit-internal
  [AT-SPI] Add notification for a11y name/description change
  [AT-SPI] TextController: emit characters before delete
  [AT-SPI] EmitStateChanged for togglable PushButton
  [AT-SPI] Add FOCUSABLE state to TextField and TextEditor
  [AT-SPI] Add Pause and Resume signals
  [AT-SPI] Let MarkFilter find the closest mark
  [AT-SPI] Emit ObjectPropertyChangeEvent::VALUE
  [AT-SPI] Implement proper accessibility for Slider
  [AT-SPI] Try auto-scrolling in GrabHighlight
  [AT-SPI] Override IsScrollable for Scrollable
  [AT-SPI] Support reading states and tooltips of ToggleButton
  [AT-SPI] Support gaining keyboard focus in TextField, TextEditor
  [AT-SPI] Allow two finger pan gesture
  [AT-SPI] Move setting highlightability property for controls to inheriting classes
  [AT-SPI] Make Accessible::GetName() fall back to actor name
  [AT-SPI] Fix role setting
  [AT-SPI] Squashed implementation

100 files changed:
automated-tests/execute.sh
automated-tests/src/dali-toolkit-internal/CMakeLists.txt
automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.h [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Accessible.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Controls-BridgeUp.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Controls.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Text.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Value.cpp [new file with mode: 0644]
automated-tests/src/dali-toolkit-internal/utc-Dali-ColorConversion.cpp
automated-tests/src/dali-toolkit-internal/utc-Dali-DebugRendering.cpp
automated-tests/src/dali-toolkit-internal/utc-Dali-PropertyHelper.cpp
automated-tests/src/dali-toolkit-internal/utc-Dali-TextSelectionPopup-internal.cpp
automated-tests/src/dali-toolkit-internal/utc-Dali-TextureManager.cpp
automated-tests/src/dali-toolkit-styling/CMakeLists.txt
automated-tests/src/dali-toolkit-third-party/CMakeLists.txt
automated-tests/src/dali-toolkit/CMakeLists.txt
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp [deleted file]
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h [deleted file]
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.cpp
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-test-application.h
automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp [deleted file]
automated-tests/src/dali-toolkit/utc-Dali-Button.cpp
automated-tests/src/dali-toolkit/utc-Dali-ControlWrapper.cpp
automated-tests/src/dali-toolkit/utc-Dali-PushButton.cpp
automated-tests/src/dali-toolkit/utc-Dali-RadioButton.cpp
automated-tests/src/dali-toolkit/utc-Dali-Scene3dView.cpp
automated-tests/src/dali-toolkit/utc-Dali-TableView.cpp
automated-tests/src/dali-toolkit/utc-Dali-ToggleButton.cpp
dali-toolkit/devel-api/accessibility-manager/accessibility-manager.cpp
dali-toolkit/devel-api/controls/control-devel.cpp
dali-toolkit/devel-api/controls/control-devel.h
dali-toolkit/internal/accessibility-manager/accessibility-manager-impl.cpp
dali-toolkit/internal/accessibility-manager/accessibility-manager-impl.h
dali-toolkit/internal/controls/alignment/alignment-impl.cpp
dali-toolkit/internal/controls/alignment/alignment-impl.h
dali-toolkit/internal/controls/bloom-view/bloom-view-impl.cpp
dali-toolkit/internal/controls/buttons/button-impl.cpp
dali-toolkit/internal/controls/buttons/button-impl.h
dali-toolkit/internal/controls/buttons/check-box-button-impl.cpp
dali-toolkit/internal/controls/buttons/check-box-button-impl.h
dali-toolkit/internal/controls/buttons/push-button-impl.cpp
dali-toolkit/internal/controls/buttons/push-button-impl.h
dali-toolkit/internal/controls/buttons/radio-button-impl.cpp
dali-toolkit/internal/controls/buttons/radio-button-impl.h
dali-toolkit/internal/controls/buttons/toggle-button-impl.cpp [changed mode: 0755->0644]
dali-toolkit/internal/controls/buttons/toggle-button-impl.h
dali-toolkit/internal/controls/control/control-data-impl.cpp
dali-toolkit/internal/controls/control/control-data-impl.h
dali-toolkit/internal/controls/effects-view/effects-view-impl.cpp
dali-toolkit/internal/controls/flex-container/flex-container-impl.cpp
dali-toolkit/internal/controls/gaussian-blur-view/gaussian-blur-view-impl.cpp
dali-toolkit/internal/controls/image-view/image-view-impl.cpp [changed mode: 0755->0644]
dali-toolkit/internal/controls/magnifier/magnifier-impl.cpp
dali-toolkit/internal/controls/model3d-view/model3d-view-impl.cpp
dali-toolkit/internal/controls/navigation-view/navigation-view-impl.cpp
dali-toolkit/internal/controls/navigation-view/navigation-view-impl.h
dali-toolkit/internal/controls/page-turn-view/page-turn-view-impl.cpp
dali-toolkit/internal/controls/popup/confirmation-popup-impl.cpp
dali-toolkit/internal/controls/popup/popup-impl.cpp
dali-toolkit/internal/controls/popup/popup-impl.h
dali-toolkit/internal/controls/progress-bar/progress-bar-impl.cpp [changed mode: 0755->0644]
dali-toolkit/internal/controls/progress-bar/progress-bar-impl.h [changed mode: 0755->0644]
dali-toolkit/internal/controls/scroll-bar/scroll-bar-impl.cpp
dali-toolkit/internal/controls/scroll-bar/scroll-bar-impl.h
dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.cpp
dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h
dali-toolkit/internal/controls/scrollable/scroll-view/scroll-base-impl.cpp
dali-toolkit/internal/controls/scrollable/scroll-view/scroll-base-impl.h
dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.cpp
dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h
dali-toolkit/internal/controls/scrollable/scrollable-impl.cpp
dali-toolkit/internal/controls/scrollable/scrollable-impl.h
dali-toolkit/internal/controls/shadow-view/shadow-view-impl.cpp
dali-toolkit/internal/controls/slider/slider-impl.cpp
dali-toolkit/internal/controls/slider/slider-impl.h [changed mode: 0755->0644]
dali-toolkit/internal/controls/super-blur-view/super-blur-view-impl.cpp
dali-toolkit/internal/controls/table-view/table-view-impl.cpp
dali-toolkit/internal/controls/text-controls/text-editor-impl.cpp
dali-toolkit/internal/controls/text-controls/text-editor-impl.h
dali-toolkit/internal/controls/text-controls/text-field-impl.cpp
dali-toolkit/internal/controls/text-controls/text-field-impl.h
dali-toolkit/internal/controls/text-controls/text-label-impl.cpp
dali-toolkit/internal/controls/text-controls/text-label-impl.h
dali-toolkit/internal/controls/text-controls/text-selection-popup-impl.cpp
dali-toolkit/internal/controls/text-controls/text-selection-toolbar-impl.cpp
dali-toolkit/internal/controls/tool-bar/tool-bar-impl.cpp
dali-toolkit/internal/controls/tooltip/tooltip.cpp
dali-toolkit/internal/controls/video-view/video-view-impl.cpp
dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.cpp
dali-toolkit/internal/text/text-controller-impl.cpp
dali-toolkit/internal/text/text-controller-impl.h
dali-toolkit/internal/text/text-controller.cpp [changed mode: 0755->0644]
dali-toolkit/internal/text/text-controller.h [changed mode: 0755->0644]
dali-toolkit/internal/text/text-editable-control-interface.h
dali-toolkit/public-api/controls/control-impl.cpp
dali-toolkit/public-api/controls/control.h

index 7703340..add0e78 100755 (executable)
@@ -118,7 +118,7 @@ else
         do
             echo -e "$ASCII_BOLD"
             echo -e "Executing $mod$ASCII_RESET"
-            build/src/$mod/tct-$mod-core $opt_serial $opt_noFailedRerun
+            dbus-launch build/src/$mod/tct-$mod-core $opt_serial $opt_noFailedRerun
         done
         summary_end
 
@@ -128,7 +128,7 @@ else
         summary_start
         module=$1
         shift;
-        build/src/$module/tct-$module-core $opt_serial $opt_noFailedRerun $*
+        dbus-launch build/src/$module/tct-$module-core $opt_serial $opt_noFailedRerun $*
         summary_end
 
     else
@@ -141,7 +141,7 @@ else
             if [ $ret -ne 6 ] ; then
                 if [ $opt_debug -ne 0 ] ; then
                     echo DEBUGGING:
-                    gdb --args build/src/$mod/tct-$mod-core $1
+                    dbus-launch gdb --args build/src/$mod/tct-$mod-core $1
 
                 else
                     echo $output
index 4c31f29..7aea8eb 100755 (executable)
@@ -8,6 +8,11 @@ SET(CAPI_LIB "dali-toolkit-internal")
 # List of test case sources (Only these get parsed for test cases)
 SET(TC_SOURCES
  utc-Dali-AddOns.cpp
+ utc-Dali-Accessibility-Accessible.cpp
+ utc-Dali-Accessibility-Controls.cpp
+ utc-Dali-Accessibility-Controls-BridgeUp.cpp
+ utc-Dali-Accessibility-Text.cpp
+ utc-Dali-Accessibility-Value.cpp
  utc-Dali-BidirectionalSupport.cpp
  utc-Dali-ColorConversion.cpp
  utc-Dali-Control-internal.cpp
@@ -39,7 +44,6 @@ SET(TC_SOURCES
 # Append list of test harness files (Won't get parsed for test cases)
 LIST(APPEND TC_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp
-   ../dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-application.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
@@ -77,14 +81,21 @@ LIST(APPEND TC_SOURCES
    dali-toolkit-test-utils/toolkit-text-utils.cpp
    dali-toolkit-test-utils/dummy-visual.cpp
    dali-toolkit-test-utils/test-addon-manager.cpp
+   dali-toolkit-test-utils/accessibility-test-utils.cpp
+   dali-toolkit-test-utils/dbus-wrapper.cpp
 )
 
 PKG_CHECK_MODULES(${CAPI_LIB} REQUIRED
     dali2-core
     dali2-adaptor
     dali2-toolkit
+    eldbus
+    ecore-input
+    eina
 )
 
+MESSAGE("Libraries to link with:>${${CAPI_LIB}_LIBRARIES}")
+
 ADD_COMPILE_OPTIONS( -O0 -ggdb --coverage -Wall -Werror -DDEBUG_ENABLED -fPIC )
 ADD_COMPILE_OPTIONS( ${${CAPI_LIB}_CFLAGS_OTHER} )
 
@@ -95,6 +106,8 @@ FOREACH(directory ${${CAPI_LIB}_LIBRARY_DIRS})
     SET(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} -L${directory}")
 ENDFOREACH(directory ${CAPI_LIB_LIBRARY_DIRS})
 
+STRING(STRIP ${CMAKE_CXX_LINK_FLAGS} CMAKE_CXX_LINK_FLAGS)
+
 INCLUDE_DIRECTORIES(
     ../../../
     ${${CAPI_LIB}_INCLUDE_DIRS}
diff --git a/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.cpp b/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.cpp
new file mode 100644 (file)
index 0000000..f8eec35
--- /dev/null
@@ -0,0 +1,290 @@
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.h>
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali/devel-api/common/stage.h>
+#include <dali/devel-api/adaptor-framework/accessibility-impl.h>
+#include "dbus-wrapper.h"
+
+namespace Dali {
+    namespace Accessibility {
+
+        using MethodType = TestDBusWrapper::MethodType;
+        using MessagePtr = DBusWrapper::MessagePtr;
+
+        void TestEnableSC(bool b) {
+            static bool firstTime = true;
+            if (b && firstTime) {
+                firstTime = false;
+                auto bridge = Accessibility::Bridge::GetCurrentBridge();
+                Dali::Stage stage = Dali::Stage::GetCurrent();
+                auto accessible = Accessibility::Accessible::Get( stage.GetRootLayer() );
+//                bridge->SetApplicationChild( accessible ); // BART
+                bridge->AddTopLevelWindow( accessible ); // BART
+                bridge->SetApplicationName( "TestApp" );
+                bridge->Initialize();
+
+                static bool ScreenReaderEnabled = false;
+                static bool IsEnabled = false;
+
+                auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/bus", "org.a11y.Status", "ScreenReaderEnabled", MethodType::Getter}] = [wr](const MessagePtr &m) -> MessagePtr {
+                    auto reply = wr->newReplyMessage(m);
+                    wr->Encode(reply, std::tuple<TestDBusWrapper::Variant<bool>>{ ScreenReaderEnabled });
+                    return reply;
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/bus", "org.a11y.Status", "IsEnabled", MethodType::Getter}] = [wr](const MessagePtr &m) -> MessagePtr {
+                    auto reply = wr->newReplyMessage(m);
+                    wr->Encode(reply, std::tuple<TestDBusWrapper::Variant<bool>>{ IsEnabled });
+                    return reply;
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/bus", "org.a11y.Bus", "GetAddress", MethodType::Method}] = [wr](const MessagePtr &m) -> MessagePtr {
+                    auto reply = wr->newReplyMessage(m);
+                    wr->Encode(reply, std::tuple<const char*>{ "bus" });
+                    return reply;
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible/root", "org.a11y.atspi.Socket", "Embed", MethodType::Method}] = [wr](const MessagePtr &m) -> MessagePtr {
+                    auto reply = wr->newReplyMessage(m);
+                    wr->Encode(reply, std::tuple<Address>{ {"bus", "root"} });
+                    return reply;
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "PropertyChange", MethodType::Method}] =
+                [wr](const MessagePtr &m) -> MessagePtr {
+                    return wr->newReplyMessage(m);
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "StateChanged", MethodType::Method}] =
+                [wr](const MessagePtr &m) -> MessagePtr {
+                    return wr->newReplyMessage(m);
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "BoundsChanged", MethodType::Method}] =
+                [wr](const MessagePtr &m) -> MessagePtr {
+                    return wr->newReplyMessage(m);
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "ActiveDescendantChanged", MethodType::Method}] =
+                [wr](const MessagePtr &m) -> MessagePtr {
+                    return wr->newReplyMessage(m);
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "TextChanged", MethodType::Method}] =
+                [wr](const MessagePtr &m) -> MessagePtr {
+                    return wr->newReplyMessage(m);
+                };
+                wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "TextCaretMoved", MethodType::Method}] =
+                [wr](const MessagePtr &m) -> MessagePtr {
+                    return wr->newReplyMessage(m);
+                };
+            }
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            wr->fromTestChangeProperty("/org/a11y/bus", "org.a11y.Status", "ScreenReaderEnabled", b);
+            wr->fromTestChangeProperty("/org/a11y/bus", "org.a11y.Status", "IsEnabled", b);
+        }
+
+        std::vector<Address> TestGetChildren(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall<std::vector<Address>>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetChildren", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        std::string TestGetName(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto name = wr->fromTestGet<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "Name");
+            return name;
+        }
+
+        std::string TestGetDescription(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto description = wr->fromTestGet<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "Description");
+            return description;
+        }
+
+        uint32_t TestGetRole(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall<uint32_t>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetRole", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        std::string TestGetRoleName(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetRoleName", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        Address TestGetParent(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestGet< Address >(adr.GetPath(), "org.a11y.atspi.Accessible", "Parent");
+            return chs;
+        }
+
+        std::string TestGetLocalizedRoleName(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetLocalizedRoleName", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        std::array< uint32_t, 2 > TestGetStates(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall<std::array< uint32_t, 2 >>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetState", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        std::unordered_map< std::string, std::string > TestGetAttributes(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall<std::unordered_map< std::string, std::string >>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetAttributes", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        bool TestDoGesture(const Address &adr, Dali::Accessibility::Gesture type, int32_t xBeg, int32_t xEnd, int32_t yBeg, int32_t yEnd, Dali::Accessibility::GestureState state, uint32_t eventTime)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Accessible", "DoGesture",
+                std::tuple< Dali::Accessibility::Gesture, int32_t, int32_t, int32_t, int32_t, Dali::Accessibility::GestureState, uint32_t >(type, xBeg, xEnd, yBeg, yEnd, state, eventTime ));
+            return std::move(std::get<0>(chs));
+        }
+
+        std::vector< std::tuple< uint32_t, std::vector< Dali::Accessibility::Address > > > TestGetRelationSet(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< std::vector< std::tuple< uint32_t, std::vector< Dali::Accessibility::Address > > > >(adr.GetPath(), "org.a11y.atspi.Accessible", "GetRelationSet", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        Address TestGetChildAtIndex(const Address &adr, int index)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< Address >(adr.GetPath(), "org.a11y.atspi.Accessible", "GetChildAtIndex", std::tuple< int >( index ));
+            return std::move(std::get<0>(chs));
+        }
+
+        ComponentLayer TestGetLayer(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< Dali::Accessibility::ComponentLayer >(adr.GetPath(), "org.a11y.atspi.Component", "GetLayer", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        int TestGetIndexInParent(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< int >(adr.GetPath(), "org.a11y.atspi.Accessible", "GetIndexInParent", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        bool TestGrabFocus(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Component", "GrabFocus", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        bool TestGrabHighlight(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Component", "GrabHighlight", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        bool TestClearHighlight(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Component", "ClearHighlight", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        std::tuple< int32_t, int32_t, int32_t, int32_t > TestGetExtents(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< std::tuple< int32_t, int32_t, int32_t, int32_t > >(adr.GetPath(), "org.a11y.atspi.Component", "GetExtents", std::tuple<uint32_t>(0));
+            return std::move(std::get<0>(chs));
+        }
+
+        int TestGetMdiZOrder(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< int16_t >(adr.GetPath(), "org.a11y.atspi.Component", "GetMDIZOrder", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        double TestGetAlpha(const Address &adr)
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< double >(adr.GetPath(), "org.a11y.atspi.Component", "GetAlpha", std::tuple<>());
+            return std::move(std::get<0>(chs));
+        }
+
+        std::string TestGetActionName( const Address &adr, size_t index )
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetName", std::tuple< int32_t >( index ));
+            return std::move(std::get<0>(chs));
+        }
+
+        std::string TestGetLocalizedActionName( const Address &adr, size_t index )
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetLocalizedName", std::tuple< int32_t >( index ));
+            return std::move(std::get<0>(chs));
+        }
+
+        size_t TestGetActionCount( const Address &adr )
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto count = wr->fromTestGet< int32_t >(adr.GetPath(), "org.a11y.atspi.Action", "NActions");
+            return count;
+        }
+
+        bool TestDoAction ( const Address &adr, size_t index )
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Action", "DoAction", std::tuple< int32_t >( index ));
+            return std::move(std::get<0>(chs));
+        }
+
+        bool TestDoAction ( const Address &adr, const std::string& name )
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Action", "DoActionName", std::tuple< std::string >( name ));
+            return std::move(std::get<0>(chs));
+        }
+
+        std::string TestGetActionKeyBinding ( const Address &adr, size_t index )
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetKeyBinding", std::tuple< int32_t >( index ));
+            return std::move(std::get<0>(chs));
+        }
+
+        std::string TestGetActionDescription ( const Address &adr, size_t index )
+        {
+            auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+            auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetDescription", std::tuple< int32_t >( index ));
+            return std::move(std::get<0>(chs));
+        }
+
+
+        void printTree(const Address &root, size_t depth)
+        {
+            auto name = TestGetName(root);
+            printf("%10s", root.GetPath().c_str());
+            for(unsigned int i = 0; i < depth; ++i) printf("  ");
+            printf("%s\n", name.c_str());
+            auto chs = TestGetChildren(root);
+            for(auto &c : chs)
+                printTree(c, depth + 1);
+        }
+
+        bool Find( const std::vector< std::string > &collection, const std::string &key)
+        {
+            for ( auto& it : collection)
+                if( it == key )
+                    return true;
+            return false;
+        }
+    }
+}
diff --git a/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.h b/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.h
new file mode 100644 (file)
index 0000000..8c3d201
--- /dev/null
@@ -0,0 +1,43 @@
+#ifndef __DALI_TOOLKIT_ACCESSIBILITY_TEST_UTILS__
+#define __DALI_TOOLKIT_ACCESSIBILITY_TEST_UTILS__
+
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+
+
+namespace Dali {
+    namespace Accessibility {
+        void TestEnableSC(bool b);
+        std::vector<Address> TestGetChildren(const Address &adr);
+        std::string TestGetName(const Address &adr);
+        std::string TestGetDescription(const Address &adr);
+        uint32_t TestGetRole(const Address &adr);
+        std::string TestGetRoleName(const Address &adr);
+        Address TestGetParent(const Address &adr);
+        std::string TestGetLocalizedRoleName(const Address &adr);
+        std::array< uint32_t, 2 > TestGetStates(const Address &adr);
+        std::unordered_map< std::string, std::string > TestGetAttributes(const Address &adr);
+        bool TestDoGesture(const Address &adr, Dali::Accessibility::Gesture type, int32_t xBeg, int32_t xEnd, int32_t yBeg, int32_t yEnd, Dali::Accessibility::GestureState state, uint32_t eventTime);
+        std::vector< std::tuple< uint32_t, std::vector< Dali::Accessibility::Address > > > TestGetRelationSet(const Address &adr);
+        Address TestGetChildAtIndex(const Address &adr, int index);
+        ComponentLayer TestGetLayer(const Address &adr);
+        int TestGetIndexInParent(const Address &adr);
+        bool TestGrabFocus(const Address &adr);
+        bool TestGrabHighlight(const Address &adr);
+        bool TestClearHighlight(const Address &adr);
+        std::tuple< int32_t, int32_t, int32_t, int32_t > TestGetExtents(const Address &adr);
+        int TestGetMdiZOrder(const Address &adr);
+        double TestGetAlpha(const Address &adr);
+        void printTree(const Address &root, size_t depth = 0);
+        bool Find( const std::vector< std::string > &collection, const std::string &key);
+        std::string TestGetActionName( const Address &adr, size_t index );
+        std::string TestGetLocalizedActionName( const Address &adr, size_t index );
+        size_t TestGetActionCount( const Address &adr );
+        bool TestDoAction ( const Address &adr, size_t index );
+        bool TestDoAction ( const Address &adr, const std::string& name );
+        std::string TestGetActionKeyBinding ( const Address &adr, size_t index );
+        std::string TestGetActionDescription ( const Address &adr, size_t index );
+
+    }
+}
+
+#endif //__DALI_TOOLKIT_ACCESSIBILITY_TEST_UTILS__
diff --git a/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.cpp b/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.cpp
new file mode 100644 (file)
index 0000000..d59df19
--- /dev/null
@@ -0,0 +1,1085 @@
+/*
+ * Copyright 2019  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.
+ */
+
+// CLASS HEADER
+#include "dbus-wrapper.h"
+
+//#include <dali/internal/accessibility/bridge/accessibility-common.h>
+
+// EXTERNAL INCLUDES
+#include <sstream>
+#include <iostream>
+#include <mutex>
+
+#include <Eldbus.h>
+#include <Ecore_Input.h>
+
+// INTERNAL INCLUDES
+#include <dali/public-api/dali-adaptor-common.h>
+
+#define DBUS_INTERFACE_PROPERTIES "org.freedesktop.DBus.Properties"
+
+#undef EINA_FALSE
+#undef EINA_TRUE
+#define EINA_TRUE static_cast< Eina_Bool >( 1 )
+#define EINA_FALSE static_cast< Eina_Bool >( 0 )
+
+//#define DBUS_DEBUG(...) do { DBus::debugPrint(__FILE__, __LINE__, __VA_ARGS__); } while (0)
+
+// BART QUICK HACK
+#undef assert
+#define assert(x) do{}while(0)
+
+std::atomic< unsigned int > DBus::detail::CallId::LastId{0};
+static std::function< void( const char*, size_t ) > debugPrinter;
+static std::mutex debugLock;
+
+thread_local std::string DBus::DBusServer::currentObjectPath;
+thread_local DBusWrapper::ConnectionPtr DBus::DBusServer::currentConnection;
+
+void DBus::setDebugPrinter( std::function< void( const char*, size_t ) > printer )
+{
+  std::lock_guard< std::mutex > lock( debugLock );
+  debugPrinter = std::move( printer );
+}
+
+void DBus::debugPrint( const char* file, size_t line, const char* format, ... )
+{
+  std::function< void( const char*, size_t ) > debugPrintFunc;
+  {
+    std::lock_guard< std::mutex > lock( debugLock );
+    if( !debugPrinter )
+      return;
+    debugPrintFunc = debugPrinter;
+  }
+  std::vector< char > buf( 4096 );
+  int offset;
+  while( true )
+  {
+    offset = snprintf( buf.data(), buf.size(), "%s:%u: ", file, static_cast< unsigned int >( line ) );
+    if( offset < 0 )
+      return;
+    if( static_cast< size_t >( offset ) < buf.size() )
+      break;
+    buf.resize( offset + 1 );
+  }
+
+  while( true )
+  {
+    va_list args;
+    va_start( args, format );
+    int z = vsnprintf( buf.data() + offset, buf.size() - offset, format, args );
+    va_end( args );
+    if( z < 0 )
+      return;
+    bool done = static_cast< size_t >( z ) + static_cast< size_t >( offset ) < buf.size();
+    buf.resize( static_cast< size_t >( z ) + static_cast< size_t >( offset ) );
+    if( done )
+      break;
+  }
+  debugPrintFunc( buf.data(), buf.size() );
+}
+
+DBusWrapper::ConnectionPtr DBus::getDBusConnectionByName( const std::string& name )
+{
+  return DBUS_W->eldbus_address_connection_get_impl( name );
+}
+
+DBusWrapper::ConnectionPtr DBus::getDBusConnectionByType( ConnectionType connectionType )
+{
+  return DBUS_W->eldbus_connection_get_impl(connectionType);
+}
+
+DBus::DBusClient::DBusClient( std::string busName, std::string pathName, std::string interfaceName, ConnectionType tp ) : DBusClient( std::move( busName ), std::move( pathName ), std::move( interfaceName ), getDBusConnectionByType( tp ) )
+{
+}
+
+DBus::DBusClient::DBusClient( std::string busName, std::string pathName, std::string interfaceName, const DBusWrapper::ConnectionPtr &conn )
+{
+  if( !conn )
+    connectionState->connection = getDBusConnectionByType( ConnectionType::SESSION );
+  else
+    connectionState->connection = conn;
+
+  std::ostringstream o;
+  o << "bus = " << busName << " path = " << pathName << " connection = " << DBUS_W->eldbus_connection_unique_name_get_impl( connectionState->connection );
+  info = o.str();
+
+  connectionState->object = DBUS_W->eldbus_object_get_impl( connectionState->connection, busName.c_str(), pathName.c_str() );
+  if( connectionState->object )
+  {
+    connectionState->proxy = DBUS_W->eldbus_proxy_get_impl( connectionState->object, interfaceName );
+    if( interfaceName != DBUS_INTERFACE_PROPERTIES )
+    {
+      connectionState->propertiesProxy = DBUS_W->eldbus_proxy_get_impl( connectionState->object, DBUS_INTERFACE_PROPERTIES );
+    }
+    else
+    {
+      connectionState->propertiesProxy = DBUS_W->eldbus_proxy_copy_impl( connectionState->proxy );
+    }
+  }
+  connectionInfo = std::make_shared< ConnectionInfo >();
+  connectionInfo->busName = std::move( busName );
+  connectionInfo->pathName = std::move( pathName );
+  connectionInfo->interfaceName = std::move( interfaceName );
+}
+
+DBus::DBusServer::DBusServer( ConnectionType tp ) : DBus::DBusServer( DBus::getDBusConnectionByType( tp ) )
+{
+}
+
+DBus::DBusServer::DBusServer( const DBusWrapper::ConnectionPtr &conn )
+{
+  if( !conn )
+    connection = getDBusConnectionByType( ConnectionType::SESSION );
+  else
+    connection = conn;
+}
+
+DBus::DBusInterfaceDescription::DBusInterfaceDescription( std::string interfaceName ) : interfaceName( std::move( interfaceName ) )
+{
+}
+
+void DBus::DBusServer::addInterface( const std::string& pathName, DBusInterfaceDescription& dscr, bool fallback )
+{
+  DBUS_W->add_interface_impl( fallback, pathName, connection, destructorObject->destructors, dscr.interfaceName, dscr.methods, dscr.properties, dscr.signals );
+}
+
+std::string DBus::DBusServer::getBusName() const
+{
+  return getConnectionName( connection );
+}
+
+std::string DBus::getConnectionName( const DBusWrapper::ConnectionPtr &c )
+{
+  return DBUS_W->eldbus_connection_unique_name_get_impl( c );
+}
+
+bool DBus::DBusClient::getFromEinaValue(const _Eina_Value *v, void *dst)
+{
+  return eina_value_get(const_cast<Eina_Value*>(v), dst);
+}
+
+/// \cond
+static std::unique_ptr<DBusWrapper> InstalledWrapper;
+
+struct DefaultDBusWrapper : public DBusWrapper {
+  constexpr static int ELDBUS_CALL_TIMEOUT = 1000;
+
+  DefaultDBusWrapper() {
+  }
+  ~DefaultDBusWrapper() {
+  }
+  #define DEFINE_GS(name, eldbus_name, unref_call) \
+    static eldbus_name *get(const std::shared_ptr<name> &a) { \
+      return static_cast<name ## Impl*>(a.get())->Value; \
+    } \
+    static eldbus_name *release(const std::shared_ptr<name> &a) { \
+      auto z = static_cast<name ## Impl*>(a.get())->Value; \
+      static_cast<name ## Impl*>(a.get())->Value = nullptr; \
+      return z; \
+    } \
+    template <typename ... ARGS> static std::shared_ptr<name> create(const eldbus_name *v, ARGS && ... args) { \
+      return std::make_shared<name ## Impl>(const_cast<eldbus_name*>(v), std::forward<ARGS>(args)...); \
+    }
+
+  #define DEFINE_TYPE(name, eldbus_name, unref_call) \
+  struct name ## Impl : public name { \
+    eldbus_name *Value = nullptr; \
+    bool EraseOnExit = false; \
+    name ## Impl(eldbus_name *Value, bool EraseOnExit = false) : Value(Value), EraseOnExit(EraseOnExit) { } \
+    ~name ## Impl() { \
+      if (EraseOnExit && Value) { unref_call; } \
+    } \
+  }; \
+  DEFINE_GS(name, eldbus_name, unref_call)
+
+  struct ConnectionImpl : public Connection {
+    Eldbus_Connection *Value = nullptr;
+    bool EraseOnExit = false;
+    ConnectionImpl(Eldbus_Connection *Value, bool EraseOnExit = false) : Value(Value), EraseOnExit(EraseOnExit) {
+      ecore_event_init();
+      eldbus_init();
+    }
+    ~ConnectionImpl() {
+      if (EraseOnExit && Value) {
+        eldbus_connection_unref( Value );
+      }
+      eldbus_shutdown();
+      ecore_event_shutdown();
+    }
+  };
+  struct MessageIterImpl : public MessageIter {
+    Eldbus_Message_Iter *Value = nullptr, *Parent = nullptr;
+    bool EraseOnExit = false;
+    MessageIterImpl(Eldbus_Message_Iter *Value, Eldbus_Message_Iter *Parent, bool EraseOnExit = false) : Value(Value), Parent(Parent), EraseOnExit(EraseOnExit) { }
+    ~MessageIterImpl() {
+      if (EraseOnExit && Value && Parent)
+        eldbus_message_iter_container_close(Parent, Value);
+    }
+  };
+
+  DEFINE_GS(Connection, Eldbus_Connection, )
+  DEFINE_GS(MessageIter, Eldbus_Message_Iter, )
+  DEFINE_TYPE(Message, Eldbus_Message, eldbus_message_unref( Value ))
+  DEFINE_TYPE(Proxy, Eldbus_Proxy, )
+  DEFINE_TYPE(Object, Eldbus_Object, eldbus_object_unref( Value ))
+  DEFINE_TYPE(Pending, Eldbus_Pending, )
+  DEFINE_TYPE(EventPropertyChanged, Eldbus_Proxy_Event_Property_Changed, )
+  #undef DEFINE_TYPE
+
+  std::shared_ptr<Connection> eldbus_address_connection_get_impl(const std::string &addr) override {
+    eldbus_init();
+    auto p = eldbus_address_connection_get(addr.c_str());
+    auto w = create(p, true);
+    eldbus_shutdown();
+    return w;
+  }
+
+#define eldbus_message_iter_arguments_append_impl_basic(type, sig) \
+  void eldbus_message_iter_arguments_append_impl(const MessageIterPtr &it, type src) override { \
+    eldbus_message_iter_arguments_append( get(it), #sig, src ); \
+  } \
+  bool eldbus_message_iter_get_and_next_impl(const MessageIterPtr &it, type &dst) override { \
+    return eldbus_message_iter_get_and_next( get(it), (#sig)[0], &dst ); \
+  }
+
+  eldbus_message_iter_arguments_append_impl_basic(uint8_t, y)
+  eldbus_message_iter_arguments_append_impl_basic(uint16_t, q)
+  eldbus_message_iter_arguments_append_impl_basic(uint32_t, u)
+  eldbus_message_iter_arguments_append_impl_basic(uint64_t, t)
+  eldbus_message_iter_arguments_append_impl_basic(int16_t, n)
+  eldbus_message_iter_arguments_append_impl_basic(int32_t, i)
+  eldbus_message_iter_arguments_append_impl_basic(int64_t, x)
+  eldbus_message_iter_arguments_append_impl_basic(double, d)
+
+#undef eldbus_message_iter_arguments_append_impl_basic
+
+  void eldbus_message_iter_arguments_append_impl(const MessageIterPtr &it, bool src) override {
+    eldbus_message_iter_arguments_append( get(it), "b", src ? 1 : 0 );
+  }
+  bool eldbus_message_iter_get_and_next_impl(const MessageIterPtr &it, bool &dst) override {
+    unsigned char q;
+    auto z = eldbus_message_iter_get_and_next( get(it), 'b', &q );
+    dst = q != 0;
+    return z;
+  }
+  void eldbus_message_iter_arguments_append_impl(const MessageIterPtr &it, const std::string &src) override {
+    eldbus_message_iter_arguments_append( get(it), "s", src.c_str() );
+  }
+  bool eldbus_message_iter_get_and_next_impl(const MessageIterPtr &it, std::string &dst) override {
+    auto iter = get(it);
+    const char* q;
+    if( !eldbus_message_iter_get_and_next( iter, 's', &q ) )
+    {
+      if( !eldbus_message_iter_get_and_next( iter, 'o', &q ) )
+        return false;
+    }
+    dst = q;
+    return true;
+  }
+  void eldbus_message_iter_arguments_append_impl(const MessageIterPtr &it, const ObjectPath &src) override {
+    eldbus_message_iter_arguments_append( get(it), "o", src.value.c_str() );
+  }
+  bool eldbus_message_iter_get_and_next_impl(const MessageIterPtr &it, ObjectPath &dst) override {
+    const char* q;
+    if( !eldbus_message_iter_get_and_next( get(it), 'o', &q ) )
+      return false;
+    dst.value = q;
+    return true;
+  }
+
+  MessageIterPtr eldbus_message_iter_container_new_impl(const MessageIterPtr &it, int type, const std::string &sig) override {
+    auto z = eldbus_message_iter_container_new( get(it), type, !sig.empty() ? sig.c_str() : NULL );
+    return create(z, get(it), true);
+  }
+  MessageIterPtr eldbus_message_iter_get_and_next_by_type_impl(const MessageIterPtr &it, int type) override {
+    Eldbus_Message_Iter* entry;
+    if (!eldbus_message_iter_get_and_next( get(it), type, &entry ) ) return {};
+    return create(entry, get(it), false);
+  }
+  MessageIterPtr eldbus_message_iter_get_impl(const MessagePtr &msg, bool) override {
+    return create(eldbus_message_iter_get(get(msg)), nullptr, false);
+  }
+  MessagePtr eldbus_proxy_method_call_new_impl(const ProxyPtr &proxy, const std::string &funcName) {
+    return create(eldbus_proxy_method_call_new( get(proxy), funcName.c_str() ) );
+  }
+  MessagePtr eldbus_proxy_send_and_block_impl(const ProxyPtr &proxy, const MessagePtr &msg) override {
+    return create(eldbus_proxy_send_and_block(get(proxy), release(msg), ELDBUS_CALL_TIMEOUT) );
+  }
+  bool eldbus_message_error_get_impl(const MessagePtr &msg, std::string &name, std::string &text) override {
+    const char *errname, *errmsg;
+    if( eldbus_message_error_get( get(msg), &errname, &errmsg ) ) {
+      name = errname;
+      text = errmsg;
+      return true;
+    }
+    return false;
+  }
+  std::string eldbus_message_signature_get_impl(const MessagePtr &msg) override {
+    return eldbus_message_signature_get(get(msg));
+  }
+
+  static void callAsyncCb( void* data, const Eldbus_Message *msg,  Eldbus_Pending *pending )
+  {
+    auto d = static_cast< SendCallback* >( data );
+    (*d)( create(msg, false) );
+  }
+  static void pendingFreeCb( void* data, const void* )
+  {
+    auto d = static_cast< SendCallback* >( data );
+    delete d;
+  }
+  static void listenerCallbackFree( void* data, const void* )
+  {
+    auto d = static_cast< std::function< void( const Eldbus_Message* msg ) >* >( data );
+    delete d;
+  }
+
+  PendingPtr eldbus_proxy_send_impl(const ProxyPtr &proxy, const MessagePtr &msg, const SendCallback &callback) override {
+    auto cb = new SendCallback{ callback };
+    auto pending = eldbus_proxy_send( get(proxy), release(msg), callAsyncCb, cb, ELDBUS_CALL_TIMEOUT );
+    if( pending )
+    {
+      eldbus_pending_free_cb_add( pending, pendingFreeCb, cb );
+    }
+    else
+    {
+      delete cb;
+    }
+    return create(pending, false);
+  }
+  std::string eldbus_proxy_interface_get_impl(const ProxyPtr &proxy) override {
+    return eldbus_proxy_interface_get( get(proxy) );
+  }
+  static void listenerCallback( void* data, const Eldbus_Message* msg )
+  {
+    auto p = static_cast< std::function< void( const Eldbus_Message* msg ) >* >( data );
+    ( *p )( msg );
+  }
+  void eldbus_proxy_signal_handler_add_impl(const ProxyPtr &proxy, const std::string &member, const std::function<void(const MessagePtr &)> &cb) override {
+    auto tmp = new std::function< void( const Eldbus_Message* msg ) >{
+      [cb](const Eldbus_Message* msg) {
+        cb(create(msg, false));
+      }
+    };
+    auto handler = eldbus_proxy_signal_handler_add( get(proxy), member.c_str(), listenerCallback, tmp );
+    if( handler )
+      eldbus_proxy_free_cb_add( get(proxy), listenerCallbackFree, tmp );
+    else
+      delete tmp;
+  }
+  std::string eldbus_message_iter_signature_get_impl(const MessageIterPtr &iter) override {
+    return eldbus_message_iter_signature_get( get(iter) );
+  }
+  MessagePtr eldbus_message_method_return_new_impl( const MessagePtr &msg) override {
+    return create(eldbus_message_method_return_new( get(msg) ) );
+  }
+  MessagePtr eldbus_message_error_new_impl( const MessagePtr &msg, const std::string &err, const std::string &txt ) override {
+    return create(eldbus_message_error_new( get(msg), err.c_str(), txt.c_str() ) );
+  }
+  PendingPtr eldbus_connection_send_impl(const ConnectionPtr &conn, const MessagePtr &msg) override {
+    return create(eldbus_connection_send( get(conn), get(msg), NULL, NULL, -1 ) );
+  }
+  MessagePtr eldbus_message_signal_new_impl(const std::string &path, const std::string &iface, const std::string &name) override {
+    return create(eldbus_message_signal_new( path.c_str(), iface.c_str(), name.c_str() ) );
+  }
+  MessagePtr eldbus_message_ref_impl(const MessagePtr &msg) override {
+    return create(eldbus_message_ref( get(msg) ), true );
+  }
+  ConnectionPtr eldbus_connection_get_impl(ConnectionType type) override {
+    Eldbus_Connection_Type eldbusType = ELDBUS_CONNECTION_TYPE_SYSTEM;
+
+    switch( type )
+    {
+      case ConnectionType::SYSTEM:
+      {
+        eldbusType = ELDBUS_CONNECTION_TYPE_SYSTEM;
+        break;
+      }
+      case ConnectionType::SESSION:
+      {
+        eldbusType = ELDBUS_CONNECTION_TYPE_SESSION;
+        break;
+      }
+    }
+
+    eldbus_init();
+    auto p = eldbus_connection_get( eldbusType );
+    auto w = create(p, true);
+    eldbus_shutdown();
+    return w;
+  }
+  std::string eldbus_connection_unique_name_get_impl(const ConnectionPtr &conn) override {
+    return eldbus_connection_unique_name_get( get(conn) );
+  }
+  ObjectPtr eldbus_object_get_impl( const ConnectionPtr &conn, const std::string &bus, const std::string &path ) override {
+      return create(eldbus_object_get(get(conn), bus.c_str(), path.c_str() ), true );
+  }
+  ProxyPtr eldbus_proxy_get_impl( const ObjectPtr &obj, const std::string &interface ) override {
+    return create(eldbus_proxy_get(get(obj), interface.c_str() ), false );
+  }
+  ProxyPtr eldbus_proxy_copy_impl( const ProxyPtr &ptr) override {
+    return create(get(ptr), false );
+  }
+
+
+
+
+
+
+  struct Implementation
+  {
+    Eldbus_Service_Interface_Desc dsc;
+    std::vector< std::vector< Eldbus_Arg_Info > > argsInfos;
+    std::vector< Eldbus_Method > methods;
+    std::vector< Eldbus_Signal > signals;
+    std::vector< Eldbus_Property > properties;
+
+    std::unordered_map< std::string, DBusWrapper::MethodInfo > methodsMap;
+    std::unordered_map< std::string, DBusWrapper::PropertyInfo > propertiesMap;
+    std::unordered_map< unsigned int, DBusWrapper::SignalInfo > signalsMap;
+
+    DBusWrapper::ConnectionWeakPtr connection;
+  };
+
+  static std::unordered_map< const Eldbus_Service_Interface*, std::unique_ptr< Implementation > > globalEntries;
+  static std::mutex globalEntriesMutex;
+
+#undef EINA_FALSE
+#undef EINA_TRUE
+#define EINA_FALSE static_cast<Eina_Bool>(0)
+#define EINA_TRUE static_cast<Eina_Bool>(1)
+
+  static Eina_Bool property_get_callback( const Eldbus_Service_Interface* iface, const char* propertyName, Eldbus_Message_Iter* iter,
+                                          const Eldbus_Message* message, Eldbus_Message** error )
+  {
+    Implementation* impl = nullptr;
+    {
+      std::lock_guard< std::mutex > lock( globalEntriesMutex );
+      auto it = globalEntries.find( iface );
+      if( it != globalEntries.end() )
+        impl = it->second.get();
+    }
+    if( !impl )
+      return EINA_FALSE;
+
+    auto it = impl->propertiesMap.find( propertyName );
+    if( it == impl->propertiesMap.end() || !it->second.getCallback )
+      return EINA_FALSE;
+
+    auto connection = impl->connection.lock();
+    if( !connection )
+      return EINA_FALSE;
+
+    DBus::DBusServer::CurrentObjectSetter currentObjectSetter( connection, eldbus_message_path_get( message ) );
+    auto reply = it->second.getCallback( create(message, false), create(iter, nullptr, false) );
+    if( !reply.empty() )
+    {
+      if( error )
+        *error = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", reply.c_str() );
+      return EINA_FALSE;
+    }
+
+    return EINA_TRUE;
+  }
+
+  static Eldbus_Message* property_set_callback( const Eldbus_Service_Interface* iface, const char* propertyName, Eldbus_Message_Iter* iter,
+                                                const Eldbus_Message* message )
+  {
+    Implementation* impl = nullptr;
+    {
+      std::lock_guard< std::mutex > lock( globalEntriesMutex );
+      auto it = globalEntries.find( iface );
+      if( it != globalEntries.end() )
+        impl = it->second.get();
+    }
+    if( !impl )
+    {
+      auto ret = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", "Unknown interface" );
+      return ret;
+    }
+    auto it = impl->propertiesMap.find( propertyName );
+    if( it == impl->propertiesMap.end() || !it->second.setCallback )
+    {
+      auto ret = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", "Unknown setter" );
+      return ret;
+    }
+    auto connection = impl->connection.lock();
+    if( !connection )
+    {
+      auto ret = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", "Connection lost" );
+      return ret;
+    }
+
+    DBus::DBusServer::CurrentObjectSetter currentObjectSetter( connection, eldbus_message_path_get( message ) );
+    auto reply = it->second.setCallback( create(message, false), create(iter, nullptr, false) );
+
+    Eldbus_Message* ret = nullptr;
+    if( !reply.empty() )
+    {
+      ret = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", reply.c_str() );
+    }
+    else
+    {
+      ret = eldbus_message_method_return_new( message );
+    }
+    return ret;
+  }
+
+  static Eldbus_Message* method_callback( const Eldbus_Service_Interface* iface, const Eldbus_Message* message )
+  {
+    Implementation* impl = nullptr;
+    {
+      std::lock_guard< std::mutex > lock( globalEntriesMutex );
+      auto it = globalEntries.find( iface );
+      if( it != globalEntries.end() )
+        impl = it->second.get();
+    }
+    if( !impl )
+    {
+      auto ret = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", "Unknown interface" );
+      return ret;
+    }
+    std::string memberName = eldbus_message_member_get( message );
+    auto it = impl->methodsMap.find( memberName );
+    if( it == impl->methodsMap.end() )
+    {
+      auto ret = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", "Unknown method" );
+      return ret;
+    }
+    auto connection = impl->connection.lock();
+    if( !connection )
+    {
+      auto ret = eldbus_message_error_new( message, "org.freedesktop.DBus.Error.Failed", "Connection lost" );
+      return ret;
+    }
+    DBus::DBusServer::CurrentObjectSetter currentObjectSetter( connection, eldbus_message_path_get( message ) );
+    auto reply = it->second.callback( create(message) );
+    return release(reply);
+  }
+
+  void add_interface_impl( bool fallback, const std::string& pathName,
+                              const ConnectionPtr &connection,
+                              std::vector<std::function<void()>> &destructors,
+                              const std::string& interfaceName,
+                              std::vector< MethodInfo >& dscrMethods,
+                              std::vector< PropertyInfo >& dscrProperties,
+                              std::vector< SignalInfo >& dscrSignals ) override
+  {
+    std::vector< Eldbus_Method > methods;
+    std::vector< Eldbus_Signal > signals;
+    std::vector< Eldbus_Property > properties;
+    std::vector< std::vector< Eldbus_Arg_Info > > argsInfos;
+    std::unordered_map< std::string, DBus::DBusInterfaceDescription::MethodInfo > methodsMap;
+    std::unordered_map< std::string, DBus::DBusInterfaceDescription::PropertyInfo > propertiesMap;
+    std::unordered_map< unsigned int, DBus::DBusInterfaceDescription::SignalInfo > signalsMap;
+
+    DBUS_DEBUG( "interface %s path %s on bus %s", interfaceName.c_str(), pathName.c_str(), DBus::getConnectionName( connection ).c_str() );
+    auto makeArgInfo = [&](const std::vector<std::pair<std::string, std::string>> &input) {
+      argsInfos.push_back({});
+      auto &dst = argsInfos.back();
+      for(auto &s : input) {
+        auto a = Strings.add(s.first);
+        auto b = Strings.add(s.second);
+        dst.push_back({ a, b });
+      }
+      dst.push_back({ nullptr, nullptr });
+      return dst.data();
+    };
+    for( auto& ee : dscrMethods )
+    {
+      auto key = ee.memberName;
+      DBUS_DEBUG( "adding method %s", ee.memberName.c_str() );
+      for( auto& r : ee.in )
+      {
+        DBUS_DEBUG( "in %s '%s'", r.first.c_str(), r.second.c_str() );
+      }
+      for( auto& r : ee.out )
+      {
+        DBUS_DEBUG( "out %s '%s'", r.first.c_str(), r.second.c_str() );
+      }
+      auto& e = ( methodsMap[key] = std::move( ee ) );
+      methods.push_back( {} );
+      auto& m = methods.back();
+      m.member = e.memberName.c_str();
+      m.in = makeArgInfo(e.in);
+      m.out = makeArgInfo(e.out);
+      m.cb = method_callback;
+      m.flags = 0;
+    }
+    for( auto& ee : dscrProperties )
+    {
+      auto key = ee.memberName;
+      DBUS_DEBUG( "adding property %s", ee.memberName.c_str() );
+      auto& e = ( propertiesMap[key] = std::move( ee ) );
+      properties.push_back( {} );
+      auto& m = properties.back();
+      m.name = e.memberName.c_str();
+      m.type = e.typeSignature.c_str();
+      m.get_func = e.getCallback ? property_get_callback : nullptr;
+      m.set_func = e.setCallback ? property_set_callback : nullptr;
+      m.flags = 0;
+    }
+    dscrMethods.clear();
+    dscrProperties.clear();
+    dscrSignals.clear();
+
+    methods.push_back( {nullptr, nullptr, nullptr, nullptr, 0} );
+    signals.push_back( {nullptr, nullptr, 0} );
+    properties.push_back( {nullptr, nullptr, nullptr, nullptr, 0} );
+
+    auto impl = std::unique_ptr< Implementation >( new Implementation{
+        {interfaceName.c_str(),
+        methods.data(),
+        signals.data(),
+        properties.data(),
+        nullptr,
+        nullptr},
+        std::move( argsInfos ),
+        std::move( methods ),
+        std::move( signals ),
+        std::move( properties ),
+        std::move( methodsMap ),
+        std::move( propertiesMap ),
+        std::move( signalsMap ),
+        connection} );
+
+    {
+      std::lock_guard< std::mutex > lock( globalEntriesMutex );
+      auto v = fallback ? eldbus_service_interface_fallback_register( get(connection), pathName.c_str(), &impl->dsc ) : eldbus_service_interface_register( get(connection), pathName.c_str(), &impl->dsc );
+      assert( v );
+      globalEntries[v] = std::move( impl );
+      DBUS_DEBUG( "registering interface %p (%d)", v, fallback ? 1 : 0 );
+      destructors.push_back([=]() {
+        DBUS_DEBUG( "unregistering interface %p", v );
+        eldbus_service_interface_unregister( v );
+        std::lock_guard< std::mutex > lock( globalEntriesMutex );
+        globalEntries.erase( v );
+      });
+    }
+  }
+  static void listenerEventChangedCallback( void* data, Eldbus_Proxy* proxy EINA_UNUSED, void* event )
+  {
+    auto p = static_cast< std::function< void( Eldbus_Proxy_Event_Property_Changed* ) >* >( data );
+    ( *p )( static_cast< Eldbus_Proxy_Event_Property_Changed* >( event ) );
+  }
+  static void ProxyEventCallbackDelCb( void* data, const void *obj )
+  {
+    auto d = static_cast< std::function< void( Eldbus_Proxy_Event_Property_Changed* ) >* >( data );
+    delete d;
+  }
+  void add_property_changed_event_listener_impl( const ProxyPtr &proxy, const std::string &interface, const std::string &name, std::function< void( const Eina_Value * ) > cb) override {
+    auto callbackLambdaPtr = new std::function< void( Eldbus_Proxy_Event_Property_Changed *epc ) >{
+      [cb, name, interface]( Eldbus_Proxy_Event_Property_Changed *ev ) {
+      const char* ifc = eldbus_proxy_interface_get( ev->proxy );
+      if( ev->name && ev->name == name && ifc && interface == ifc )
+      {
+        cb(ev->value);
+      }
+    } };
+    auto p = get(proxy);
+    eldbus_proxy_event_callback_add( p, ELDBUS_PROXY_EVENT_PROPERTY_CHANGED,
+                                     listenerEventChangedCallback, callbackLambdaPtr );
+    eldbus_proxy_free_cb_add( p, ProxyEventCallbackDelCb, callbackLambdaPtr );
+  }
+};
+
+std::unordered_map< const Eldbus_Service_Interface*, std::unique_ptr< DefaultDBusWrapper::Implementation > > DefaultDBusWrapper::globalEntries;
+std::mutex DefaultDBusWrapper::globalEntriesMutex;
+
+DBusWrapper *DBusWrapper::Installed()
+{
+  if (!InstalledWrapper)
+    InstalledWrapper.reset(new DefaultDBusWrapper);
+  return InstalledWrapper.get();
+}
+
+void DBusWrapper::Install(std::unique_ptr<DBusWrapper> w)
+{
+  InstalledWrapper = std::move(w);
+}
+
+
+struct TestDBusWrapper::ConnectionImpl : public TestDBusWrapper::Connection {
+};
+
+TestDBusWrapper::TestDBusWrapper()
+{
+  eina_init();
+  connection = std::make_shared<ConnectionImpl>();
+  testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/bus", "org.a11y.Status", "ScreenReaderEnabled", MethodType::Getter}] =
+  testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/bus", "org.a11y.Status", "IsEnabled", MethodType::Getter}] =
+  [this](const DBusWrapper::MessagePtr &m) -> MessagePtr {
+    auto reply = newReplyMessage(m);
+    Encode(reply, std::tuple<TestDBusWrapper::Variant<bool>>{ TestDBusWrapper::Variant<bool>{ false} });
+    return reply;
+  };
+}
+TestDBusWrapper::~TestDBusWrapper()
+{
+  eina_shutdown();
+}
+
+TestDBusWrapper::ConnectionPtr TestDBusWrapper::eldbus_address_connection_get_impl(const std::string &addr)
+{
+  return connection;
+}
+
+struct TestDBusWrapper::MessageIterImpl : public TestDBusWrapper::MessageIter {
+  MessagePtr msg;
+  Element *elem;
+  bool write;
+  std::list<Element>::iterator it;
+  MessageIterImpl(MessagePtr msg, Element *elem, bool write) : msg(std::move(msg)), elem(elem), write(write) {
+    if (!write) it = elem->get<ElementList>().begin();
+  }
+  MessageIterImpl(MessagePtr msg, Element *elem, bool write, std::list<Element>::iterator it) : msg(std::move(msg)), elem(elem), write(write), it(it) { }
+};
+
+struct TestDBusWrapper::MessageImpl : public TestDBusWrapper::Message {
+  std::string bus, path, interface, name;
+  Element data;
+  bool reply, error = false;
+  std::string error_a, error_b;
+
+  MessageImpl(std::string bus, std::string path, std::string interface, std::string name, bool reply) :
+    bus(std::move(bus)), path(std::move(path)), interface(std::move(interface)), name(std::move(name)), data{ ElementList{} }, reply(reply) { }
+  MessageImpl(std::string bus, std::string path, std::string interface, std::string name, std::string error_a, std::string error_b) :
+    bus(std::move(bus)), path(std::move(path)), interface(std::move(interface)), name(std::move(name)), data{ ElementList{} },
+    reply(true), error(true), error_a(std::move(error_a)), error_b(std::move(error_b)) { }
+};
+
+struct TestDBusWrapper::ProxyImpl : public TestDBusWrapper::Proxy {
+  std::string bus, path, interface;
+  ProxyImpl(std::string bus, std::string path, std::string interface) : bus(std::move(bus)), path(std::move(path)), interface(std::move(interface)) { }
+};
+struct TestDBusWrapper::ObjectImpl : public TestDBusWrapper::Object {
+  std::string bus, path;
+  ObjectImpl(std::string bus, std::string path) : bus(std::move(bus)), path(std::move(path)) { }
+};
+#define DEFINE_TYPE(name) TestDBusWrapper::name ## Impl *TestDBusWrapper::get(const name ## Ptr &v) { return static_cast<name ## Impl*>(v.get()); }
+  DEFINE_TYPE(Connection)
+  DEFINE_TYPE(Proxy)
+  DEFINE_TYPE(Object)
+  DEFINE_TYPE(Message)
+  DEFINE_TYPE(MessageIter)
+#undef DEFINE_TYPE
+
+template <typename T> void TestDBusWrapperAppendBasic(const TestDBusWrapper::MessageIterPtr &it, T src) {
+  auto m = TestDBusWrapper::get(it);
+  if (!m->write) throw TestDBusWrapper::error{};
+  if (!m->elem->isContainer()) throw TestDBusWrapper::error{};
+  m->elem->get<TestDBusWrapper::ElementList>().push_back(TestDBusWrapper::Element{ src });
+}
+template <typename T> bool TestDBusWrapperGetBasicAndNext(const TestDBusWrapper::MessageIterPtr &it, T &src) {
+  auto m = TestDBusWrapper::get(it);
+  if (m->write) throw TestDBusWrapper::error{};
+  if (!m->elem->isContainer()) return false;
+  auto &lst = m->elem->get<TestDBusWrapper::ElementList>();
+  if (m->it == lst.end()) return false;
+  if (!m->it->is<T>()) return false;
+  src = m->it->get<T>();
+  ++m->it;
+  return true;
+}
+
+#define eldbus_message_iter_arguments_append_impl_basic_impl(type_set, type_get, sig) \
+void TestDBusWrapper::eldbus_message_iter_arguments_append_impl(const MessageIterPtr &it, type_set src) { \
+  TestDBusWrapperAppendBasic(it, src); \
+} \
+bool TestDBusWrapper::eldbus_message_iter_get_and_next_impl(const MessageIterPtr &it, type_get &dst) { \
+  return TestDBusWrapperGetBasicAndNext(it, dst); \
+}
+#define eldbus_message_iter_arguments_append_impl_basic(type, sig) \
+eldbus_message_iter_arguments_append_impl_basic_impl(type, type, sig)
+
+eldbus_message_iter_arguments_append_impl_basic(uint8_t, y)
+eldbus_message_iter_arguments_append_impl_basic(uint16_t, q)
+eldbus_message_iter_arguments_append_impl_basic(uint32_t, u)
+eldbus_message_iter_arguments_append_impl_basic(uint64_t, t)
+eldbus_message_iter_arguments_append_impl_basic(int16_t, n)
+eldbus_message_iter_arguments_append_impl_basic(int32_t, i)
+eldbus_message_iter_arguments_append_impl_basic(int64_t, x)
+eldbus_message_iter_arguments_append_impl_basic(double, d)
+eldbus_message_iter_arguments_append_impl_basic(bool, b)
+eldbus_message_iter_arguments_append_impl_basic_impl(const std::string &, std::string, s)
+eldbus_message_iter_arguments_append_impl_basic_impl(const ObjectPath &, ObjectPath, o)
+
+#undef eldbus_message_iter_arguments_append_impl_basic
+#undef eldbus_message_iter_arguments_append_impl_basic_impl
+
+TestDBusWrapper::MessageIterPtr TestDBusWrapper::eldbus_message_iter_container_new_impl(const MessageIterPtr &it, int type, const std::string &sig) {
+  auto m = get(it);
+  if (!m->write) throw error{};
+  if (!m->elem->isContainer()) throw error{};
+  auto &lst = m->elem->get<ElementList>();
+  if (type == 'r' || type == 'e' || type == 'a' || type == 'v') {
+    lst.push_back({ ElementList{}, type });
+    return std::make_shared<MessageIterImpl>(MessageIterImpl{ m->msg, &lst.back(), true });
+  }
+  throw error{};
+}
+
+TestDBusWrapper::MessageIterPtr TestDBusWrapper::eldbus_message_iter_get_and_next_by_type_impl(const MessageIterPtr &it, int type) {
+  auto m = get(it);
+  if (m->write) throw error{};
+  if (!m->elem->isContainer()) throw error{} << "not a container";
+  auto &lst = m->elem->get<ElementList>();
+  if (m->it == lst.end()) return {};
+  if (m->it->signature() != type) return {};
+  auto v = std::make_shared<MessageIterImpl>(MessageIterImpl{ m->msg, &*m->it, false });
+  ++m->it;
+  return v;
+}
+
+TestDBusWrapper::MessageIterPtr TestDBusWrapper::eldbus_message_iter_get_impl(const MessagePtr &it, bool write) {
+  auto m = get(it);
+  return std::make_shared<MessageIterImpl>(MessageIterImpl{ it, &m->data, write, m->data.get<ElementList>().begin() });
+}
+
+bool TestDBusWrapper::completed(const MessageIterPtr &iter)
+{
+  auto m = get(iter);
+  assert(!m->write);
+  return m->it == m->elem->get<ElementList>().end();
+}
+
+TestDBusWrapper::MessagePtr TestDBusWrapper::eldbus_proxy_method_call_new_impl(const ProxyPtr &proxy, const std::string &funcName) {
+  auto p = get(proxy);
+  return std::make_shared<MessageImpl>(MessageImpl{
+    p->bus, p->path, p->interface, funcName, false
+  });
+}
+TestDBusWrapper::MessagePtr TestDBusWrapper::call(
+    std::unordered_map<std::tuple<std::string, std::string, std::string, MethodType>, std::function<MessagePtr(const MessagePtr&)>> &mp,
+    const std::string &mpName, const MessagePtr &msg, MethodType type) {
+  auto m = get(msg);
+  auto findMethod = [&](std::string path, const std::string &iname, const std::string &name, MethodType type) {
+    if (path.empty()) throw error{};
+    if (path[0] != '/') {
+      path = "/org/a11y/atspi/accessible/" + path;
+      m->path = path;
+    }
+    while(!path.empty()) {
+      auto it = mp.find(std::tuple<std::string, std::string, std::string, MethodType> { path, iname, name, type });
+      if (it != mp.end()) return it;
+      auto index = path.rfind('/');
+      if (index == std::string::npos) break;
+      path.resize(index);
+    }
+    return mp.end();
+  };
+  std::string iname, name;
+  if (type == MethodType::Method && m->interface == "org.freedesktop.DBus.Properties") {
+    type = m->name == "Get" ? MethodType::Getter : MethodType::Setter;
+    auto &lst = m->data.get<ElementList>();
+    assert(lst.size() >= 2);
+    iname = lst.front().get<std::string>();
+    lst.pop_front();
+    name = lst.front().get<std::string>();
+    lst.pop_front();
+  }
+  else {
+    iname = m->interface;
+    name = m->name;
+  }
+  auto it = findMethod(m->path, iname, name, type);
+  if (it == mp.end()) {
+    const char *mt;
+    if (type == MethodType::Method) mt = "MethodType::Method";
+    else if (type == MethodType::Getter) mt = "MethodType::Getter";
+    else if (type == MethodType::Setter) mt = "MethodType::Setter";
+    else assert(0);
+    throw error{} << "missing {\"" << m->path << "\", \"" << iname << "\", \"" << name << "\", " << mt << "} in " << mpName;
+  }
+  DBus::DBusServer::CurrentObjectSetter setter{ connection, m->path };
+  return it->second(msg);
+}
+TestDBusWrapper::MessagePtr TestDBusWrapper::eldbus_proxy_send_and_block_impl(const ProxyPtr &proxy, const MessagePtr &msg) {
+// BART
+//  auto p = get(proxy);
+//  auto m = get(msg);
+//  assert(p->bus == m->bus);
+//  assert(p->path == m->path);
+//  assert(p->interface == m->interface);
+  return call(testMethods, "testMethods", msg, MethodType::Method);
+}
+
+bool TestDBusWrapper::eldbus_message_error_get_impl(const MessagePtr &msg, std::string &name, std::string &text) {
+  auto m = get(msg);
+  name = m->error_a;
+  text = m->error_b;
+  return m->error;
+}
+static void calculate_signature(std::ostringstream &ostr, TestDBusWrapper::Element &e)
+{
+  ostr << static_cast<char>(e.signature());
+  if (e.isContainer()) {
+    ostr << "(";
+    auto &lst = e.get<TestDBusWrapper::ElementList>();
+    for(auto &q : lst) calculate_signature(ostr, q);
+    ostr << ")";
+  }
+}
+std::string TestDBusWrapper::eldbus_message_signature_get_impl(const MessagePtr &msg) {
+  auto m = get(msg);
+  std::ostringstream ostr;
+  for(auto &q : m->data.get<ElementList>())
+    calculate_signature(ostr, q);
+  return ostr.str();
+}
+TestDBusWrapper::PendingPtr TestDBusWrapper::eldbus_proxy_send_impl(const ProxyPtr &proxy, const MessagePtr &msg, const SendCallback &callback) {
+// BART
+//  auto p = get(proxy);
+//  auto m = get(msg);
+//  assert(p->bus == m->bus);
+//  assert(p->path == m->path);
+//  assert(p->interface == m->interface);
+  asyncCalls.push_back([this, msg, callback]() {
+    auto r = call(testMethods, "testMethods", msg, MethodType::Method);
+    callback(r);
+  });
+  return {};
+}
+std::string TestDBusWrapper::eldbus_proxy_interface_get_impl(const ProxyPtr &proxy) {
+  auto p = get(proxy);
+  return p->interface;
+}
+void TestDBusWrapper::eldbus_proxy_signal_handler_add_impl(const ProxyPtr &proxy, const std::string &member, const std::function<void(const MessagePtr &)> &cb) {
+  auto p = get(proxy);
+  daliSignals[std::tuple<std::string, std::string, std::string> { p->path, p->interface, member }] = cb;
+}
+std::string TestDBusWrapper::eldbus_message_iter_signature_get_impl(const MessageIterPtr &iter) {
+  auto m = get(iter);
+  if (m->write) throw error{};
+  if (!m->elem->isContainer()) throw error{};
+  std::ostringstream ostr;
+  auto &lst = m->elem->get<ElementList>();
+  for(auto it = m->it; it != lst.end(); ++it)
+    calculate_signature(ostr, *it);
+  return ostr.str();
+}
+TestDBusWrapper::MessagePtr TestDBusWrapper::eldbus_message_method_return_new_impl( const MessagePtr &msg) {
+  auto m = get(msg);
+  return std::make_shared<MessageImpl>(MessageImpl{
+    m->bus, m->path, m->interface, m->name, true
+  });
+}
+TestDBusWrapper::MessagePtr TestDBusWrapper::eldbus_message_error_new_impl( const MessagePtr &msg, const std::string &err, const std::string &txt ) {
+  auto m = get(msg);
+  return std::make_shared<MessageImpl>(MessageImpl{
+    m->bus, m->path, m->interface, m->name, err, txt
+  });
+}
+TestDBusWrapper::PendingPtr TestDBusWrapper::eldbus_connection_send_impl(const ConnectionPtr &conn, const MessagePtr &msg) {
+  call(testMethods, "testMethods", msg, MethodType::Method);
+  return {};
+}
+std::shared_ptr<Eina_Value> TestDBusWrapper::createEinaValue(bool b) {
+  Eina_Value *value = eina_value_new(EINA_VALUE_TYPE_UCHAR);
+  eina_value_set(value, b);
+  return std::shared_ptr<Eina_Value>(value, [](Eina_Value *v) {
+    eina_value_free(v);
+  });
+}
+
+TestDBusWrapper::MessagePtr TestDBusWrapper::newMessage(const std::string &path, const std::string &interface, const std::string &name, bool reply) {
+  return std::make_shared<MessageImpl>(MessageImpl{
+    "bus", path, interface, name, reply
+  });
+}
+
+TestDBusWrapper::MessagePtr TestDBusWrapper::newReplyMessage(const MessagePtr &msg) {
+  auto m = get(msg);
+  return newMessage(m->path, m->interface, m->name, true);
+}
+
+TestDBusWrapper::MessagePtr TestDBusWrapper::eldbus_message_signal_new_impl(const std::string &path, const std::string &iface, const std::string &name) {
+  return std::make_shared<MessageImpl>(MessageImpl{
+    "bus", path, iface, name, true
+  });
+}
+TestDBusWrapper::MessagePtr TestDBusWrapper::eldbus_message_ref_impl(const MessagePtr &msg) {
+  return msg;
+}
+TestDBusWrapper::ConnectionPtr TestDBusWrapper::eldbus_connection_get_impl(ConnectionType type) {
+  return connection;
+}
+std::string TestDBusWrapper::eldbus_connection_unique_name_get_impl(const ConnectionPtr &conn) {
+  return "bus";
+}
+TestDBusWrapper::ObjectPtr TestDBusWrapper::eldbus_object_get_impl( const ConnectionPtr &conn, const std::string &bus, const std::string &path ) {
+  return std::make_shared<ObjectImpl>(ObjectImpl{
+    bus, path
+  });
+}
+TestDBusWrapper::ProxyPtr TestDBusWrapper::eldbus_proxy_get_impl( const ObjectPtr &obj, const std::string &interface ) {
+  auto o = get(obj);
+  return std::make_shared<ProxyImpl>(ProxyImpl{ o->bus, o->path, interface });
+}
+TestDBusWrapper::ProxyPtr TestDBusWrapper::eldbus_proxy_copy_impl( const ProxyPtr &ptr) {
+  return ptr;
+}
+void TestDBusWrapper::add_property_changed_event_listener_impl( const ProxyPtr &proxy, const std::string &interface, const std::string &name, std::function< void( const Eina_Value * ) > cb) {
+  auto p = get(proxy);
+  propertyChangeListeners[std::tuple<std::string, std::string, std::string>{ p->path, interface, name }] = cb;
+}
+void TestDBusWrapper::add_interface_impl( bool fallback, const std::string& path_,
+                            const ConnectionPtr &connection,
+                            std::vector<std::function<void()>> &destructors,
+                            const std::string& interface,
+                            std::vector< MethodInfo >& dscrMethods,
+                            std::vector< PropertyInfo >& dscrProperties,
+                            std::vector< SignalInfo >& dscrSignals ) {
+  std::string bus = "bus";
+  std::string path = path_;
+  while(!path.empty() && path.back() == '/') path.pop_back();
+  for(auto &m : dscrMethods) {
+    auto key = std::make_tuple( "/org/a11y/atspi/accessible" + path, interface, m.memberName, MethodType::Method );
+    daliMethods[key] = m.callback;
+  }
+  for(auto &m : dscrProperties) {
+    auto key = std::make_tuple( "/org/a11y/atspi/accessible" + path, interface, m.memberName, MethodType::Getter );
+    daliMethods[key] = [=](const MessagePtr &msg) -> MessagePtr {
+      auto ret = std::make_shared<MessageImpl>(MessageImpl{
+        "bus", path, interface, m.memberName, true
+      });
+      auto v = m.getCallback(msg, std::make_shared<MessageIterImpl>(MessageIterImpl{ ret, &ret->data, true }));
+      ret->error = !v.empty();
+      if (ret->error) {
+        ret->error_a = "call failed";
+        ret->error_b = std::move(v);
+      }
+      return ret;
+    };
+    std::get<3>(key) = MethodType::Setter;
+    daliMethods[key] = [=](const MessagePtr &msg) -> MessagePtr {
+      auto v = m.setCallback(msg, std::make_shared<MessageIterImpl>(MessageIterImpl{ msg, &get(msg)->data, false }));
+      return v.empty() ? std::make_shared<MessageImpl>(MessageImpl{
+        "bus", path, interface, m.memberName, true,
+      }) : std::make_shared<MessageImpl>(MessageImpl{
+        "bus", path, interface, m.memberName, "call failed", v
+      });
+       // interface is probably wrong, due to retarded way properties are handlded by dbus
+    };
+  }
+  for(auto &m : dscrSignals) {
+    daliSignalsMap[std::tuple<std::string, std::string, unsigned int>{ "/org/a11y/atspi/accessible" + path, interface, m.uniqueId }] = m.memberName;
+  }
+}
+
+/// \endcond
diff --git a/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h b/automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h
new file mode 100644 (file)
index 0000000..e44aa56
--- /dev/null
@@ -0,0 +1,3330 @@
+#ifndef DALI_INTERNAL_ACCESSIBILITY_BRIDGE_DBUS_H
+#define DALI_INTERNAL_ACCESSIBILITY_BRIDGE_DBUS_H
+
+/*
+ * Copyright 2019  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 <memory>
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <cstring>
+#include <map>
+#include <list>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+#include <functional>
+
+// INTERNAL INCLUDES
+//#include <dali/public-api/adaptor-framework/accessibility.h>
+//#include <dali/internal/accessibility/bridge/optional.h>
+
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+
+#define ATSPI_PREFIX_PATH "/org/a11y/atspi/accessible/"
+#define ATSPI_NULL_PATH "/org/a11y/atspi/null"
+
+
+//// BART QUICK HACK
+#define bart_assert(x) do{}while(0)
+
+struct _Eina_Value;
+
+/// \cond
+struct ObjectPath
+{
+  std::string value;
+};
+
+struct DBusWrapper
+{
+  virtual ~DBusWrapper() = default;
+
+  enum class ConnectionType
+  {
+    SYSTEM,
+    SESSION
+  };
+
+#define DEFINE_TYPE(name, eldbus_name, unref_call) \
+    struct name { virtual ~name() = default; }; \
+    using name ## Ptr = std::shared_ptr<name>; \
+    using name ## WeakPtr = std::weak_ptr<name>; \
+
+  DEFINE_TYPE(Connection, Eldbus_Connection, )
+  DEFINE_TYPE(MessageIter, Eldbus_Message_Iter, eldbus_message_iter_container_close( Value ))
+  DEFINE_TYPE(Message, Eldbus_Message, eldbus_message_unref( Value ))
+  DEFINE_TYPE(Proxy, Eldbus_Proxy, eldbus_proxy_unref( Value ))
+  DEFINE_TYPE(Object, Eldbus_Object, eldbus_object_unref( Value ))
+  DEFINE_TYPE(Pending, Eldbus_Pending, )
+  DEFINE_TYPE(EventPropertyChanged, Eldbus_Proxy_Event_Property_Changed, )
+
+#undef DEFINE_TYPE
+  virtual ConnectionPtr eldbus_address_connection_get_impl(const std::string &addr) = 0;
+
+#define eldbus_message_iter_arguments_append_impl_basic_impl(type_set, type_get, sig) \
+  virtual void eldbus_message_iter_arguments_append_impl(const MessageIterPtr &it, type_set src) = 0; \
+  virtual bool eldbus_message_iter_get_and_next_impl(const MessageIterPtr &it, type_get &dst) = 0;
+#define eldbus_message_iter_arguments_append_impl_basic(type, sig) \
+  eldbus_message_iter_arguments_append_impl_basic_impl(type, type, sig)
+
+  eldbus_message_iter_arguments_append_impl_basic(uint8_t, y)
+  eldbus_message_iter_arguments_append_impl_basic(uint16_t, q)
+  eldbus_message_iter_arguments_append_impl_basic(uint32_t, u)
+  eldbus_message_iter_arguments_append_impl_basic(uint64_t, t)
+  eldbus_message_iter_arguments_append_impl_basic(int16_t, n)
+  eldbus_message_iter_arguments_append_impl_basic(int32_t, i)
+  eldbus_message_iter_arguments_append_impl_basic(int64_t, x)
+  eldbus_message_iter_arguments_append_impl_basic(double, d)
+  eldbus_message_iter_arguments_append_impl_basic(bool, b)
+  eldbus_message_iter_arguments_append_impl_basic_impl(const std::string &, std::string, s)
+  eldbus_message_iter_arguments_append_impl_basic_impl(const ObjectPath &, ObjectPath, o)
+
+#undef eldbus_message_iter_arguments_append_impl_basic
+#undef eldbus_message_iter_arguments_append_impl_basic_impl
+
+  virtual MessageIterPtr eldbus_message_iter_container_new_impl(const MessageIterPtr &it, int type, const std::string &sig) = 0;
+  virtual MessageIterPtr eldbus_message_iter_get_and_next_by_type_impl(const MessageIterPtr &it, int type) = 0;
+  virtual MessageIterPtr eldbus_message_iter_get_impl(const MessagePtr &it, bool write) = 0;
+  virtual MessagePtr eldbus_proxy_method_call_new_impl(const ProxyPtr &proxy, const std::string &funcName) = 0;
+  virtual MessagePtr eldbus_proxy_send_and_block_impl(const ProxyPtr &proxy, const MessagePtr &msg) = 0;
+  virtual bool eldbus_message_error_get_impl(const MessagePtr &msg, std::string &name, std::string &text) = 0;
+  virtual std::string eldbus_message_signature_get_impl(const MessagePtr &msg) = 0;
+
+  using SendCallback = std::function<void(const MessagePtr &msg)>;
+  virtual PendingPtr eldbus_proxy_send_impl(const ProxyPtr &proxy, const MessagePtr &msg, const SendCallback &callback) = 0;
+  virtual std::string eldbus_proxy_interface_get_impl(const ProxyPtr &) = 0;
+  virtual void eldbus_proxy_signal_handler_add_impl(const ProxyPtr &proxy, const std::string &member, const std::function<void(const MessagePtr &)> &cb) = 0;
+  virtual std::string eldbus_message_iter_signature_get_impl(const MessageIterPtr &iter) = 0;
+  virtual MessagePtr eldbus_message_method_return_new_impl( const MessagePtr &msg) = 0;
+  virtual MessagePtr eldbus_message_error_new_impl( const MessagePtr &msg, const std::string &err, const std::string &txt ) = 0;
+  virtual PendingPtr eldbus_connection_send_impl(const ConnectionPtr &conn, const MessagePtr &msg) = 0;
+  virtual MessagePtr eldbus_message_signal_new_impl(const std::string &path, const std::string &iface, const std::string &name) = 0;
+  virtual MessagePtr eldbus_message_ref_impl(const MessagePtr &msg) = 0;
+  virtual ConnectionPtr eldbus_connection_get_impl(ConnectionType type) = 0;
+  virtual std::string eldbus_connection_unique_name_get_impl(const ConnectionPtr &conn) = 0;
+  virtual ObjectPtr eldbus_object_get_impl( const ConnectionPtr &conn, const std::string &bus, const std::string &path ) = 0;
+  virtual ProxyPtr eldbus_proxy_get_impl( const ObjectPtr &obj, const std::string &interface ) = 0;
+  virtual ProxyPtr eldbus_proxy_copy_impl( const ProxyPtr &ptr) = 0;
+
+  class StringStorage
+  {
+  public:
+    struct char_ptr_deleter
+    {
+      void operator()( char* p )
+      {
+        free( p );
+      }
+    };
+    std::vector< std::unique_ptr< char, char_ptr_deleter > > storage;
+
+    const char* add( const char* txt )
+    {
+      auto ptr = strdup( txt );
+      storage.push_back( std::unique_ptr< char, char_ptr_deleter >( ptr ) );
+      return storage.back().get();
+    }
+    const char* add( const std::string& txt )
+    {
+      return add( txt.c_str() );
+    }
+  };
+
+  struct CallId
+  {
+    static std::atomic< unsigned int > LastId;
+    unsigned int id = ++LastId;
+  };
+  struct MethodInfo
+  {
+    CallId id;
+    std::string memberName;
+    std::vector< std::pair<std::string, std::string> > in, out; // _Eldbus_Arg_Info
+    std::function< DBusWrapper::MessagePtr( const DBusWrapper::MessagePtr &msg ) > callback;
+  };
+  struct SignalInfo
+  {
+    CallId id;
+    std::string memberName;
+    std::vector< std::pair<std::string, std::string> > args;
+    unsigned int uniqueId;
+  };
+  struct PropertyInfo
+  {
+    CallId setterId, getterId;
+    std::string memberName, typeSignature;
+    std::function< std::string( const DBusWrapper::MessagePtr &src, const DBusWrapper::MessageIterPtr &dst ) > getCallback, setCallback;
+  };
+  struct SignalId
+  {
+    CallId id;
+
+    SignalId() = default;
+    SignalId( CallId id ) : id( id ) {}
+  };
+  virtual void add_interface_impl( bool fallback, const std::string& pathName,
+                              const ConnectionPtr &connection,
+                              std::vector<std::function<void()>> &destructors,
+                              const std::string& interfaceName,
+                              std::vector< MethodInfo >& dscrMethods,
+                              std::vector< PropertyInfo >& dscrProperties,
+                              std::vector< SignalInfo >& dscrSignals ) = 0;
+  virtual void add_property_changed_event_listener_impl( const ProxyPtr &proxy, const std::string &interface, const std::string &name, std::function< void( const _Eina_Value * ) > cb) = 0;
+  static DBusWrapper *Installed();
+  static void Install(std::unique_ptr<DBusWrapper>);
+
+  StringStorage Strings;
+};
+
+namespace detail {
+  enum class MethodType {
+    Method, Getter, Setter
+  };
+}
+
+namespace std {
+  template <> struct hash<std::tuple<std::string, std::string, std::string>> {
+    size_t operator () (const std::tuple<std::string, std::string, std::string> &a) const {
+      auto a1 = std::hash<std::string>()(std::get<0>(a));
+      auto a2 = std::hash<std::string>()(std::get<1>(a));
+      auto a3 = std::hash<std::string>()(std::get<2>(a));
+      size_t v = a1;
+      v = (v * 11400714819323198485llu) + a2;
+      v = (v * 11400714819323198485llu) + a3;
+      return v;
+    }
+  };
+  template <> struct hash<std::tuple<std::string, std::string, std::string, detail::MethodType>> {
+    size_t operator () (const std::tuple<std::string, std::string, std::string, detail::MethodType> &a) const {
+      auto a1 = std::hash<std::string>()(std::get<0>(a));
+      auto a2 = std::hash<std::string>()(std::get<1>(a));
+      auto a3 = std::hash<std::string>()(std::get<2>(a));
+      auto a4 = static_cast<size_t>(std::get<3>(a));
+      size_t v = a1;
+      v = (v * 11400714819323198485llu) + a2;
+      v = (v * 11400714819323198485llu) + a3;
+      v = (v * 11400714819323198485llu) + a4;
+      return v;
+    }
+  };
+  template <> struct hash<std::tuple<std::string, std::string, unsigned int>> {
+    size_t operator () (const std::tuple<std::string, std::string, unsigned int> &a) const {
+      auto a1 = std::hash<std::string>()(std::get<0>(a));
+      auto a2 = std::hash<std::string>()(std::get<1>(a));
+      auto a3 = std::get<2>(a);
+      size_t v = a1;
+      v = (v * 11400714819323198485llu) + a2;
+      v = (v * 11400714819323198485llu) + a3;
+      return v;
+    }
+  };
+}
+namespace detail {
+  template <typename T> struct DBusSigImpl { enum { value = 0, end = 0 }; };
+  template <typename T> struct DBusSig { enum { value = DBusSigImpl<typename std::decay<T>::type>::value, end = DBusSigImpl<typename std::decay<T>::type>::end }; };
+  template <typename T, typename Q, size_t I, size_t S> struct IndexFromTypeTupleImpl {
+    enum { value = std::is_same<typename std::decay<typename std::tuple_element<I, T>::type>::type, Q>::value ? I : IndexFromTypeTupleImpl<T, Q, I + 1, S>::value };
+  };
+  template <typename T, typename Q, size_t S> struct IndexFromTypeTupleImpl<T, Q, S, S> { enum { value = S }; };
+  template <typename T, typename Q> struct IndexFromTypeTuple {
+    enum { value = IndexFromTypeTupleImpl<T, typename std::decay<Q>::type, 0, std::tuple_size<T>::value>::value };
+  };
+  template <typename T, typename = void> struct Encoder;
+  template <size_t I, size_t S, typename ... ARGS> struct EncoderTuple;
+}
+struct TestDBusWrapper : public DBusWrapper
+{
+  using MethodType = detail::MethodType;
+  ConnectionPtr connection;
+  std::unordered_map<std::tuple<std::string, std::string, std::string, MethodType>, std::function<MessagePtr(const MessagePtr&)>> testMethods;
+  std::unordered_map<std::tuple<std::string, std::string, std::string, MethodType>, std::function<MessagePtr(const MessagePtr&)>> daliMethods;
+  std::unordered_map<std::tuple<std::string, std::string, unsigned int>, std::string> daliSignalsMap;
+  std::unordered_map<std::tuple<std::string, std::string, std::string>, std::function<void(const MessagePtr&)>> daliSignals;
+  std::unordered_map<std::tuple<std::string, std::string, std::string>, std::function<void(const _Eina_Value *)>> propertyChangeListeners;
+
+  std::vector<std::function<void()>> asyncCalls;
+
+  template <typename T> struct Variant {
+    T value;
+    Variant() = default;
+    Variant(T t) : value(std::move(t)) { }
+  };
+  template <typename ... ARGS> void Encode(const MessagePtr &m, const std::tuple<ARGS...> &args) {
+    auto iter = eldbus_message_iter_get_impl(m, true);
+    detail::EncoderTuple<0, sizeof...(ARGS), ARGS...>::encode(*this, iter, args);
+  }
+  template <typename ... ARGS> void Decode(const MessagePtr &m, std::tuple<ARGS...> &args) {
+    auto iter = eldbus_message_iter_get_impl(m, false);
+    detail::EncoderTuple<0, sizeof...(ARGS), ARGS...>::decode(*this, args, iter);
+  }
+  MessagePtr newMessage(const std::string &path, const std::string &interface, const std::string &name, bool reply);
+  MessagePtr newReplyMessage(const MessagePtr &m);
+
+  template <typename ... ARGS> void fromTestEmitSignal(std::string path, const std::string &interface, const std::string &name, const std::tuple<ARGS...> &args) {
+    if (path.empty()) throw error{};
+    if (path[0] != '/') path = "/org/a11y/atspi/accessible/" + path;
+    auto msg = newMessage(path, interface, name, false);
+    Encode(msg, args);
+    auto it = daliSignals.find(std::tuple<std::string, std::string, std::string>{ path, interface, name });
+    if (it == daliSignals.end()) throw error{};
+    it->second(msg);
+  }
+  static std::shared_ptr<_Eina_Value> createEinaValue(bool);
+  template <typename T> void fromTestChangeProperty(std::string path, const std::string &interface, const std::string &name, T new_value) {
+    auto v = createEinaValue(new_value);
+    if (path.empty()) throw error{};
+    if (path[0] != '/') path = "/org/a11y/atspi/accessible/" + path;
+    auto it = propertyChangeListeners.find(std::tuple<std::string, std::string, std::string>{ path, interface, name });
+    if (it == propertyChangeListeners.end()) throw error{};
+    it->second(v.get());
+  }
+  template <typename ... ARGS1, typename ... ARGS2> std::tuple<ARGS1...> fromTestCall(const std::string &path, const std::string &interface, const std::string &name, const std::tuple<ARGS2...> &args) {
+    auto msg = newMessage(path, interface, name, false);
+    Encode(msg, args);
+    auto res = call(daliMethods, "daliMethods", msg, MethodType::Method);
+    std::string a, b;
+    if (eldbus_message_error_get_impl(res, a, b)) throw error{} << "call to " << path << " " << interface << " " << name << " failed: " << a << ": " << b;
+    std::tuple<ARGS1...> tmp;
+    Decode(res, tmp);
+    return tmp;
+  }
+  template <typename T> T fromTestGet(const std::string &path, const std::string &interface, const std::string &name) {
+    auto msg = newMessage(path, interface, name, false);
+    auto res = call(daliMethods, "daliMethods", msg, MethodType::Getter);
+    std::string a, b;
+    if (eldbus_message_error_get_impl(res, a, b)) throw error{} << "call to " << path << " " << interface << " " << name << " failed: " << a << ": " << b;
+    std::tuple<T> tmp;
+    Decode(res, tmp);
+    return std::move(std::get<0>(tmp));
+  }
+  template <typename ... ARGS1, typename T> std::tuple<ARGS1...> fromTestSet(const std::string &path, const std::string &interface, const std::string &name, const T &arg) {
+    auto msg = newMessage(path, interface, name, false);
+    Encode(msg, TestDBusWrapper::Variant<T>{ arg });
+    auto res = call(daliMethods, "daliMethods", msg, MethodType::Setter);
+    std::string a, b;
+    if (eldbus_message_error_get_impl(res, a, b)) throw error{} << "call to " << path << " " << interface << " " << name << " failed: " << a << ": " << b;
+    std::tuple<ARGS1...> tmp;
+    Decode(res, tmp);
+    return tmp;
+  }
+
+  TestDBusWrapper();
+  ~TestDBusWrapper();
+
+  class error : public std::exception {
+    std::shared_ptr<std::ostringstream> temp = std::make_shared<std::ostringstream>();
+    mutable std::string text;
+  public:
+    error() = default;
+
+    template <typename T> error &operator << (T &&t) {
+      *temp << std::forward<T>(t);
+      return *this;
+    }
+    const char *what() const noexcept override {
+      text = temp->str();
+      return text.c_str();
+    }
+  };
+  #define DEFINE_TYPE(name) struct name ## Impl; static name ## Impl *get(const name ## Ptr &);
+  DEFINE_TYPE(Connection)
+  DEFINE_TYPE(Proxy)
+  DEFINE_TYPE(Object)
+  DEFINE_TYPE(Message)
+  DEFINE_TYPE(MessageIter)
+  #undef DEFINE_TYPE
+
+  class Element;
+  using ElementList = std::list<Element>;
+  using ElementMap = std::map<std::string, std::string>;
+  using ElementTuple = std::tuple<
+    uint8_t, uint16_t, uint32_t, uint64_t, int16_t, int32_t, int64_t, double, bool, std::string, ObjectPath,
+    ElementList
+  >;
+
+  class Element {
+    ElementTuple data;
+    char signature_ = 0, end_ = 0, index_ = 0;
+    template <typename T> void set(T &&t, char signature = detail::DBusSig<T>::value) {
+      signature_ = signature;
+      end_ = detail::DBusSig<T>::end;
+      index_ = static_cast<char>(detail::IndexFromTypeTuple<ElementTuple, T>::value);
+      get<T>() = std::forward<T>(t);
+    }
+  public:
+    template <typename T> Element(T &&t, typename std::enable_if<detail::DBusSig<T>::value != 0>::type* = nullptr) { set(std::forward<T>(t)); }
+    Element(ElementList t, int signature) { set(std::move(t), static_cast<char>(signature)); }
+
+    char signature() const { return signature_; }
+    char end() const { return end_; }
+    char index() const { return index_; }
+    bool isContainer() const { return index_ == detail::IndexFromTypeTuple<ElementTuple, ElementList>::value; }
+    template <typename T, typename = typename std::enable_if<detail::DBusSig<T>::value != 0>::type>
+    bool is() const { return index_ == detail::IndexFromTypeTuple<ElementTuple, T>::value; }
+    template <typename T, typename = typename std::enable_if<detail::DBusSig<T>::value != 0>::type>
+    const T &get() const { if (!is<T>()) throw error{}; return std::get<detail::IndexFromTypeTuple<ElementTuple, T>::value>(data); }
+    template <typename T, typename = typename std::enable_if<detail::DBusSig<T>::value != 0>::type>
+    T &get() { if (!is<T>()) throw error{}; return std::get<detail::IndexFromTypeTuple<ElementTuple, T>::value>(data); }
+  };
+
+  ConnectionPtr eldbus_address_connection_get_impl(const std::string &addr) override;
+
+#define eldbus_message_iter_arguments_append_impl_basic_impl(type_set, type_get, sig) \
+  void eldbus_message_iter_arguments_append_impl(const MessageIterPtr &it, type_set src) override; \
+  bool eldbus_message_iter_get_and_next_impl(const MessageIterPtr &it, type_get &dst) override;
+#define eldbus_message_iter_arguments_append_impl_basic(type, sig) \
+  eldbus_message_iter_arguments_append_impl_basic_impl(type, type, sig)
+
+  eldbus_message_iter_arguments_append_impl_basic(uint8_t, y)
+  eldbus_message_iter_arguments_append_impl_basic(uint16_t, q)
+  eldbus_message_iter_arguments_append_impl_basic(uint32_t, u)
+  eldbus_message_iter_arguments_append_impl_basic(uint64_t, t)
+  eldbus_message_iter_arguments_append_impl_basic(int16_t, n)
+  eldbus_message_iter_arguments_append_impl_basic(int32_t, i)
+  eldbus_message_iter_arguments_append_impl_basic(int64_t, x)
+  eldbus_message_iter_arguments_append_impl_basic(double, d)
+  eldbus_message_iter_arguments_append_impl_basic(bool, b)
+  eldbus_message_iter_arguments_append_impl_basic_impl(const std::string &, std::string, s)
+  eldbus_message_iter_arguments_append_impl_basic_impl(const ObjectPath &, ObjectPath, o)
+
+#undef eldbus_message_iter_arguments_append_impl_basic
+#undef eldbus_message_iter_arguments_append_impl_basic_impl
+
+  MessageIterPtr eldbus_message_iter_container_new_impl(const MessageIterPtr &it, int type, const std::string &sig) override;
+  MessageIterPtr eldbus_message_iter_get_and_next_by_type_impl(const MessageIterPtr &it, int type) override;
+  MessageIterPtr eldbus_message_iter_get_impl(const MessagePtr &it, bool write) override;
+  MessagePtr eldbus_proxy_method_call_new_impl(const ProxyPtr &proxy, const std::string &funcName) override;
+  MessagePtr eldbus_proxy_send_and_block_impl(const ProxyPtr &proxy, const MessagePtr &msg) override;
+  bool eldbus_message_error_get_impl(const MessagePtr &msg, std::string &name, std::string &text) override;
+  std::string eldbus_message_signature_get_impl(const MessagePtr &msg) override;
+  PendingPtr eldbus_proxy_send_impl(const ProxyPtr &proxy, const MessagePtr &msg, const SendCallback &callback) override;
+  std::string eldbus_proxy_interface_get_impl(const ProxyPtr &) override;
+  void eldbus_proxy_signal_handler_add_impl(const ProxyPtr &proxy, const std::string &member, const std::function<void(const MessagePtr &)> &cb) override;
+  std::string eldbus_message_iter_signature_get_impl(const MessageIterPtr &iter) override;
+  MessagePtr eldbus_message_method_return_new_impl( const MessagePtr &msg) override;
+  MessagePtr eldbus_message_error_new_impl( const MessagePtr &msg, const std::string &err, const std::string &txt ) override;
+  PendingPtr eldbus_connection_send_impl(const ConnectionPtr &conn, const MessagePtr &msg) override;
+  MessagePtr eldbus_message_signal_new_impl(const std::string &path, const std::string &iface, const std::string &name) override;
+  MessagePtr eldbus_message_ref_impl(const MessagePtr &msg) override;
+  ConnectionPtr eldbus_connection_get_impl(ConnectionType type) override;
+  std::string eldbus_connection_unique_name_get_impl(const ConnectionPtr &conn) override;
+  ObjectPtr eldbus_object_get_impl( const ConnectionPtr &conn, const std::string &bus, const std::string &path ) override;
+  ProxyPtr eldbus_proxy_get_impl( const ObjectPtr &obj, const std::string &interface ) override;
+  ProxyPtr eldbus_proxy_copy_impl( const ProxyPtr &ptr) override;
+  void add_property_changed_event_listener_impl( const ProxyPtr &proxy, const std::string &interface, const std::string &name, std::function< void( const _Eina_Value * ) > cb) override;
+  void add_interface_impl( bool fallback, const std::string& pathName,
+                              const ConnectionPtr &connection,
+                              std::vector<std::function<void()>> &destructors,
+                              const std::string& interfaceName,
+                              std::vector< MethodInfo >& dscrMethods,
+                              std::vector< PropertyInfo >& dscrProperties,
+                              std::vector< SignalInfo >& dscrSignals ) override;
+  static bool completed(const MessageIterPtr &iter);
+private:
+  MessagePtr call(std::unordered_map<std::tuple<std::string, std::string, std::string, MethodType>, std::function<MessagePtr(const MessagePtr&)>> &mp, const std::string &name, const MessagePtr &msg, MethodType type);
+};
+
+namespace detail {
+  template <> struct DBusSigImpl<uint8_t> { enum { value = 'y', end = 0 }; };
+  template <> struct DBusSigImpl<uint16_t> { enum { value = 'q', end = 0 }; };
+  template <> struct DBusSigImpl<uint32_t> { enum { value = 'u', end = 0 }; };
+  template <> struct DBusSigImpl<uint64_t> { enum { value = 't', end = 0 }; };
+  template <> struct DBusSigImpl<int16_t> { enum { value = 'n', end = 0 }; };
+  template <> struct DBusSigImpl<int32_t> { enum { value = 'i', end = 0 }; };
+  template <> struct DBusSigImpl<int64_t> { enum { value = 'x', end = 0 }; };
+  template <> struct DBusSigImpl<double> { enum { value = 'd', end = 0 }; };
+  template <> struct DBusSigImpl<bool> { enum { value = 'b', end = 0 }; };
+  template <> struct DBusSigImpl<std::string> { enum { value = 's', end = 0 }; };
+  template <> struct DBusSigImpl<ObjectPath> { enum { value = 'o', end = 0 }; };
+  template <> struct DBusSigImpl<TestDBusWrapper::ElementList> { enum { value = '(', end = ')' }; };
+  template <> struct DBusSigImpl<TestDBusWrapper::ElementMap> { enum { value = '{', end = '}' }; };
+
+  template <typename T> struct Encoder<T, decltype(TestDBusWrapper().eldbus_message_iter_arguments_append_impl(TestDBusWrapper::MessageIterPtr(), T()))> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const T &src) {
+      w.eldbus_message_iter_arguments_append_impl(tgt, src);
+    }
+    static void decode(TestDBusWrapper &w, T &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      if (!w.eldbus_message_iter_get_and_next_impl(src, tgt)) throw TestDBusWrapper::error{};
+    }
+  };
+  template <typename T> struct Encoder<T, typename std::enable_if<std::is_enum<T>::value>::type> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const T &src) {
+      Encoder<typename std::underlying_type<T>::type>::encode(w, tgt, static_cast<typename std::underlying_type<T>::type>(src));
+    }
+    static void decode(TestDBusWrapper &w, T &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      typename std::underlying_type<T>::type v = 0;
+      Encoder<typename std::underlying_type<T>::type>::decode(w, v, src);
+      tgt = static_cast<T>(v);
+    }
+  };
+  template <typename T> struct Encoder<const T> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const T &src) {
+      Encoder<T>::encode(w, tgt, src);
+    }
+    static void decode(TestDBusWrapper &w, T &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      Encoder<T>::decode(w, tgt, src);
+    }
+  };
+  template <typename T> struct Encoder<const T &> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const T &src) {
+      Encoder<T>::encode(w, tgt, src);
+    }
+    static void decode(TestDBusWrapper &w, T &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      Encoder<T>::decode(w, tgt, src);
+    }
+  };
+  template <typename T> struct Encoder<T &> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const T &src) {
+      Encoder<T>::encode(w, tgt, src);
+    }
+    static void decode(TestDBusWrapper &w, T &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      Encoder<T>::decode(w, tgt, src);
+    }
+  };
+  template <size_t I, size_t S, typename ... ARGS> struct EncoderTuple {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const std::tuple<ARGS...> &src) {
+      Encoder<typename std::tuple_element<I, std::tuple<ARGS...>>::type>::encode(w, tgt, std::get<I>(src));
+      EncoderTuple<I + 1, S, ARGS...>::encode(w, tgt, src);
+    }
+    static void decode(TestDBusWrapper &w, std::tuple<ARGS...> &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      Encoder<typename std::tuple_element<I, std::tuple<ARGS...>>::type>::decode(w, std::get<I>(tgt), src);
+      EncoderTuple<I + 1, S, ARGS...>::decode(w, tgt, src);
+    }
+  };
+  template <size_t S, typename ... ARGS> struct EncoderTuple<S, S, ARGS...> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const std::tuple<ARGS...> &src) { }
+    static void decode(TestDBusWrapper &w, std::tuple<ARGS...> &tgt, const TestDBusWrapper::MessageIterPtr &src) { }
+  };
+  template <typename ...ARGS> struct Encoder<std::tuple<ARGS...>> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const std::tuple<ARGS...> &src) {
+      auto var = w.eldbus_message_iter_container_new_impl( tgt, 'r', "");
+      EncoderTuple<0, sizeof...(ARGS), ARGS...>::encode(w, var, src);
+    }
+    static void decode(TestDBusWrapper &w, std::tuple<ARGS...> &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      auto s = w.eldbus_message_iter_get_and_next_by_type_impl( src, 'r' );
+      if( !s ) throw TestDBusWrapper::error{};
+      EncoderTuple<0, sizeof...(ARGS), ARGS...>::decode(w, tgt, s);
+    }
+  };
+  template <typename A, typename B> struct Encoder<std::pair<A, B>> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const std::pair<A, B> &src, char type = 'r') {
+      auto var = w.eldbus_message_iter_container_new_impl( tgt, type, "");
+      Encoder<A>::encode(w, var, src.first);
+      Encoder<B>::encode(w, var, src.second);
+    }
+    static void decode(TestDBusWrapper &w, std::pair<A, B> &tgt, const TestDBusWrapper::MessageIterPtr &src, char type = 'r') {
+      auto s = w.eldbus_message_iter_get_and_next_by_type_impl( src, type );
+      if( !s ) throw TestDBusWrapper::error{};
+      Encoder<A>::decode(w, tgt.first, s);
+      Encoder<B>::decode(w, tgt.second, s);
+    }
+  };
+  template <typename T> struct Encoder<TestDBusWrapper::Variant<T>> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const TestDBusWrapper::Variant<T> &src) {
+      //w.eldbus_message_iter_arguments_append_impl(tgt, src);
+      auto var = w.eldbus_message_iter_container_new_impl( tgt, 'v', "");
+      Encoder<T>::encode(w, var, src.value);
+    }
+    static void decode(TestDBusWrapper &w, TestDBusWrapper::Variant<T> &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      auto s = w.eldbus_message_iter_get_and_next_by_type_impl( src, 'v' );
+      if( !s ) throw TestDBusWrapper::error{};
+      Encoder<T>::decode(w, tgt.value, s);
+    }
+  };
+  template <typename T> struct Encoder<std::vector<T>> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const std::vector<T> &src) {
+      auto var = w.eldbus_message_iter_container_new_impl( tgt, 'a', "");
+      for(auto &q : src)
+        Encoder<T>::encode(w, var, q);
+    }
+    static void decode(TestDBusWrapper &w, std::vector<T> &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      auto s = w.eldbus_message_iter_get_and_next_by_type_impl( src, 'a' );
+      if( !s ) throw TestDBusWrapper::error{};
+      while(!TestDBusWrapper::completed(s)) {
+        tgt.push_back({});
+        Encoder<T>::decode(w, tgt.back(), s);
+      }
+    }
+  };
+  template <typename K, typename V> struct Encoder<std::unordered_map<K,V>> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const std::unordered_map<K,V> &src) {
+      auto var = w.eldbus_message_iter_container_new_impl( tgt, 'a', "");
+      for(auto &q : src){
+        Encoder<typename std::unordered_map<K,V>::value_type>::encode(w, var, q, 'e');
+      }
+    }
+    static void decode(TestDBusWrapper &w, std::unordered_map<K,V> &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      auto s = w.eldbus_message_iter_get_and_next_by_type_impl( src, 'a' );
+      if( !s ) throw TestDBusWrapper::error{};
+      while(!TestDBusWrapper::completed(s)) {
+        std::pair<K, V> tmp;
+        Encoder<std::pair<K,V>>::decode(w, tmp, s, 'e');
+        tgt.insert(std::move(tmp));
+      }
+    }
+  };
+  template <typename T, size_t I> struct Encoder<std::array<T, I>> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const std::array<T, I> &src) {
+      auto var = w.eldbus_message_iter_container_new_impl( tgt, 'a', "");
+      for(auto &q : src)
+        Encoder<T>::encode(w, var, q);
+    }
+    static void decode(TestDBusWrapper &w, std::array<T, I> &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      auto s = w.eldbus_message_iter_get_and_next_by_type_impl( src, 'a' );
+      if( !s ) throw TestDBusWrapper::error{};
+      size_t i = 0;
+      while(!TestDBusWrapper::completed(s)) {
+        if(i >= tgt.size()) throw TestDBusWrapper::error{};
+        Encoder<T>::decode(w, tgt[i], s);
+        ++i;
+      }
+      if( i!=tgt.size()) throw TestDBusWrapper::error{};
+    }
+  };
+  template <> struct Encoder<Dali::Accessibility::Address> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const Dali::Accessibility::Address &src) {
+      Encoder<std::tuple<std::string, ObjectPath>>::encode(w, tgt,std::tuple<std::string, ObjectPath> {
+        src.GetBus(), ObjectPath{ "/org/a11y/atspi/accessible/" + src.GetPath() } }
+      );
+    }
+    static void decode(TestDBusWrapper &w, Dali::Accessibility::Address &tgt, const TestDBusWrapper::MessageIterPtr &src) {
+      std::tuple<std::string, ObjectPath> tmp;
+      Encoder<std::tuple<std::string, ObjectPath>>::decode(w, tmp, src);
+      static const size_t prefixSize = std::string{ "/org/a11y/atspi/accessible/" }.size();
+      tgt = { std::move(std::get<0>(tmp)), std::get<1>(tmp).value.substr(prefixSize) };
+    }
+  };
+  template <> struct Encoder<const char*> {
+    static void encode(TestDBusWrapper &w, const TestDBusWrapper::MessageIterPtr &tgt, const char *src) {
+      Encoder<std::string>::encode(w, tgt, src);
+    }
+  };
+}
+/// \endcond
+
+#define DBUS_DEBUG( ... )                                \
+  do                                                     \
+  {                                                      \
+    DBus::debugPrint( __FILE__, __LINE__, __VA_ARGS__ ); \
+  } while( 0 )
+
+#define DBUS_W DBusWrapper::Installed()
+
+/**
+ * @brief Template based, single file, wrapper library around eldbus for DBUS based communication.
+ *
+ * Main motivation was missing asynchronous calls in AT-SPI library and difficulties,
+ * when using eldbus from C++.
+ *
+ * The library:
+ * - takes care of marshalling arguments to and from DBUS calls.
+ * - allows synchronous and asynchronous calls.
+ * - allows synchronous and asynchronous listeners on signals.
+ * - manages all involved objects' lifetimes.
+ * - errors are passed as optional-alike objects, no exceptions are used.
+ * - allows setting additional debug-print function for more details about
+ *   what's going on
+ *
+ * DBUS's method signatures (and expected return values) are specified as template argument,
+ * using functor syntax. For example:
+ * \code{.cpp}
+ * auto dbus = DBusClient{ ... };
+ * auto v = dbus.method<std::tuple<int, float>(float, float, std::string)>("foo").call(1.0f, 2.0f, "qwe");
+ * \endcode
+ * means (synchronous) call on dbus object, which takes three arguments (thus making call signature \b dds)
+ * of types float, float and string (float will be automatically converted to double).
+ * Expected return value is std::tuple<int, float>, which gives signature <B>(id)</B> - std::tuple acts
+ * as struct container. Returned value v will be of type ValueOrError<std::tuple<int, float>>.\n
+ * Slightly different (asynchronous) example:
+ * \code{.cpp}
+ * auto dbus = DBusClient{ ... };
+ * std::function<void(ValueOrError<int, float>)> callback;
+ * dbus.method<ValueOrError<int, float>(float, float, std::string)>("foo").asyncCall(callback, 1.0f, 2.0f, "qwe");
+ * \endcode
+ * Now the call takes the same arguments and has the same signature. But expected values are different -
+ * now the signature is simply \b id. ValueOrError acts in this case as placeholder for list of values,
+ * which DBUS allows as return data. The call itself is asynchronous - instead of expecting reply
+ * you need to pass a callback, which will be called either with received data and error message.
+ *
+ * Library is not thread-safe, the same object shouldn't be called from different threads without
+ * synchronization. There's no guarantee, that callbacks will be executed on the same thread.
+ */
+namespace DBus
+{
+/// \cond
+class DBusServer;
+class DBusClient;
+class DBusInterfaceDescription;
+
+/**
+ * @brief Formats debug message and calls debug printer (if any) with it
+ */
+void debugPrint( const char* file, size_t line, const char* format, ... );
+
+/**
+ * @brief Sets debug printer callback, which will be called with debug messages
+ *
+ * Callback will be called in various moments of DBus activity. First value passed to callback
+ * is pointer to text, second it's length. Text is ended with 0 (not counted towards it's size),
+ * user can safely printf it.
+ */
+void setDebugPrinter( std::function< void( const char*, size_t ) > );
+
+struct Error
+{
+  std::string message;
+
+  Error() = default;
+  Error( std::string msg ) : message( std::move( msg ) )
+  {
+    bart_assert( !message.empty() );
+  }
+};
+
+struct Success
+{
+};
+/// \endcond
+
+/**
+ * @brief Value representing data, that came from DBUS or error message
+ *
+ * Object of this class either helds series of values (of types ARGS...)
+ * or error message. This object will be true in boolean context, if has data
+ * and false, if an error occured.
+ * It's valid to create ValueOrError object with empty argument list or void:
+ * \code{.cpp}
+ * ValueOrError<> v1;
+ * ValueOrError<void> v2;
+ * \endcode
+ * Both mean the same - ValueOrError containing no real data and being a marker,
+ * wherever operation successed or failed and containing possible error message.
+ */
+template < typename... ARGS >
+class ValueOrError
+{
+public:
+  /**
+   * @brief Empty constructor. Valid only, if all ARGS types are default constructible.
+   */
+  ValueOrError() = default;
+
+  /**
+   * @brief Value constructor.
+   *
+   * This will be initialized as success with passed in values.
+   */
+  ValueOrError( ARGS... t ) : value( std::move( t )... ) {}
+
+  /**
+   * @brief Alternative Value constructor.
+   *
+   * This will be initialized as success with passed in values.
+   */
+  ValueOrError( std::tuple< ARGS... > t ) : value( std::move( t ) ) {}
+
+  /**
+   * @brief Error constructor. This will be initialized as failure with given error message.
+   */
+  ValueOrError( Error e ) : error( std::move( e ) )
+  {
+    bart_assert( !error.message.empty() );
+  }
+
+  /**
+   * @brief bool operator.
+   *
+   * Returns true, if operation was successful (getValues member is callable), or false
+   * when operation failed (getError is callable).
+   */
+  explicit operator bool() const
+  {
+    return error.message.empty();
+  }
+
+  /**
+   * @brief Returns error message object.
+   *
+   * Returns object containing error message associated with the failed operation.
+   * Only callable, if operation actually failed, otherwise will bart_assert.
+   */
+  const Error& getError() const
+  {
+    return error;
+  }
+
+  /**
+   * @brief Returns modifiable tuple of held data.
+   *
+   * Returns reference to the internal tuple containing held data.
+   * User can modify (or move) data safely.
+   * Only callable, if operation actually successed, otherwise will bart_assert.
+   */
+  std::tuple< ARGS... >& getValues()
+  {
+    bart_assert( *this );
+    return value;
+  }
+
+  /**
+   * @brief Returns const tuple of held data.
+   *
+   * Returns const reference to the internal tuple containing held data.
+   * Only callable, if operation actually successed, otherwise will bart_assert.
+   */
+  const std::tuple< ARGS... >& getValues() const
+  {
+    bart_assert( *this );
+    return value;
+  }
+
+protected:
+  /// \cond
+  std::tuple< ARGS... > value;
+  Error error;
+  /// \endcond
+};
+
+/// \cond
+template <>
+class ValueOrError<>
+{
+public:
+  ValueOrError() = default;
+  ValueOrError( std::tuple<> t ) {}
+  ValueOrError( Error e ) : error( std::move( e ) )
+  {
+    bart_assert( !error.message.empty() );
+  }
+
+  explicit operator bool() const
+  {
+    return error.message.empty();
+  }
+  const Error& getError() const
+  {
+    return error;
+  }
+  std::tuple<>& getValues()
+  {
+    bart_assert( *this );
+    static std::tuple<> t;
+    return t;
+  }
+  std::tuple<> getValues() const
+  {
+    bart_assert( *this );
+    return {};
+  }
+
+protected:
+  Error error;
+};
+
+template <>
+class ValueOrError< void >
+{
+public:
+  ValueOrError() = default;
+  ValueOrError( Success ) {}
+  ValueOrError( Error e ) : error( std::move( e ) )
+  {
+    bart_assert( !error.message.empty() );
+  }
+
+  explicit operator bool() const
+  {
+    return error.message.empty();
+  }
+  const Error& getError() const
+  {
+    return error;
+  }
+  std::tuple<>& getValues()
+  {
+    bart_assert( *this );
+    static std::tuple<> t;
+    return t;
+  }
+  std::tuple<> getValues() const
+  {
+    bart_assert( *this );
+    return {};
+  }
+
+protected:
+  Error error;
+};
+
+using ObjectPath = ObjectPath;
+
+/// \endcond
+
+/**
+ * @brief Class used to marshall DBUS's variant type
+ *
+ * Minimalistic class, that allows user to specify DBUS variant type
+ * as argument or return value. You need to pass real type hidden under variant as
+ * template type \b A. At this point library doesn't allow to expected one of few classes
+ * as return data in variant. So for example user can't specify method call, which on return
+ * expects DBUS variant holding either string or int.
+ */
+template < typename A >
+struct EldbusVariant
+{
+  A value;
+};
+
+/**
+ * @brief Namespace for private, internal functions and classes
+ */
+namespace detail
+{
+/// \cond
+template < typename T, typename = void >
+struct signature;
+template < typename... ARGS >
+struct signature< std::tuple< ARGS... > >;
+template < typename A, typename B >
+struct signature< std::pair< A, B > >;
+template < typename A >
+struct signature< std::vector< A > >;
+template < typename A, size_t N >
+struct signature< std::array< A, N > >;
+template < typename A, typename B >
+struct signature< std::unordered_map< A, B > >;
+template < typename A, typename B >
+struct signature< std::map< A, B > >;
+/// \endcond
+
+/**
+ * @brief Signature class for marshalling uint8 type.
+ */
+template <>
+struct signature< uint8_t >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "uint8_t";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "y";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, uint8_t v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, uint8_t& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+/**
+ * @brief Signature class for marshalling uint16 type.
+ */
+template <>
+struct signature< uint16_t >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "uint16_t";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "q";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, uint16_t v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, uint16_t& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+/**
+ * @brief Signature class for marshalling uint32 type.
+ */
+template <>
+struct signature< uint32_t >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "uint32_t";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "u";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, uint32_t v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, uint32_t& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+/**
+ * @brief Signature class for marshalling uint64 type.
+ */
+template <>
+struct signature< uint64_t >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "uint64_t";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "t";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, uint64_t v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, uint64_t& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+/**
+ * @brief Signature class for marshalling int16 type.
+ */
+template <>
+struct signature< int16_t >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "int16_t";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "n";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, int16_t v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, int16_t& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+/**
+ * @brief Signature class for marshalling int32 type.
+ */
+template <>
+struct signature< int32_t >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "int32_t";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "i";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, int32_t v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, int32_t& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+/**
+ * @brief Signature class for marshalling int64 type.
+ */
+template <>
+struct signature< int64_t >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "int64_t";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "x";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, int64_t v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, int64_t& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+/**
+ * @brief Signature class for marshalling double type.
+ */
+template <>
+struct signature< double >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "double";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "d";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, double v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, double& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, float& v2 )
+  {
+    double v = 0;
+    auto r = DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+    v2 = static_cast< float >( v );
+    return r;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling float type.
+ */
+template <>
+struct signature< float >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "float";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "d";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, float v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, double& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, float& v2 )
+  {
+    double v = 0;
+    auto r = DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+    v2 = static_cast< float >( v );
+    return r;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling boolean type.
+ */
+template <>
+struct signature< bool >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "bool";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "b";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, bool v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, bool& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+template < typename T >
+struct signature< T, typename std::enable_if< std::is_enum< T >::value, void >::type >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "enum";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return signature<typename std::underlying_type<T>::type>::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, T v )
+  {
+    signature<typename std::underlying_type<T>::type>::set(iter, static_cast< int64_t >( v ));
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, T& v )
+  {
+    typename std::underlying_type<T>::type q = 0;
+    if (!signature<typename std::underlying_type<T>::type>::get(iter, q))
+      return false;
+
+    v = static_cast< T >( q );
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling string type.
+ *
+ * Both (const) char * and std::string types are accepted as value to send.
+ * Only std::string is accepted as value to receive.
+ */
+template <>
+struct signature< std::string >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "string";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "s";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::string& v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+// /**
+//  * @brief Marshals value v as marshalled type into message
+//  */
+//  static void set( const DBusWrapper::MessageIterPtr &iter, const char* v )
+//  {
+//    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+//  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::string& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+};
+
+template <>
+struct signature< ObjectPath >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "path";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "o";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::string& v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, ObjectPath{ v });
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const ObjectPath& v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const char* v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, ObjectPath{ v });
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, ObjectPath& v )
+  {
+    return DBUS_W->eldbus_message_iter_get_and_next_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::string& v )
+  {
+    ObjectPath q;
+    if (!DBUS_W->eldbus_message_iter_get_and_next_impl(iter, q)) return false;
+    v = std::move(q.value);
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling (const) char * type.
+ *
+ * Both (const) char * and std::string types are accepted as value to send.
+ * You can't use (const) char * variable type to receive value.
+ */
+template <>
+struct signature< char* >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "string";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "s";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::string& v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, v);
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const char* v )
+  {
+    DBUS_W->eldbus_message_iter_arguments_append_impl(iter, std::string{ v });
+  }
+};
+/// \cond
+
+template < size_t INDEX, typename A, typename... ARGS >
+struct signature_tuple_element_type_helper
+{
+  using type = typename signature_tuple_element_type_helper< INDEX - 1, ARGS... >::type;
+};
+
+template < typename A, typename... ARGS >
+struct signature_tuple_element_type_helper< 0, A, ARGS... >
+{
+  using type = A;
+};
+/// \endcond
+
+/**
+ * @brief Helper class to marshall tuples
+ *
+ * This class marshals all elements of the tuple value starting at the index INDEX
+ * and incrementing. This class recursively calls itself with increasing INDEX value
+ * until INDEX is equal to SIZE, where recursive calling ends.
+ */
+template < size_t INDEX, size_t SIZE, typename... ARGS >
+struct signature_tuple_helper
+{
+  using current_type = typename signature_tuple_element_type_helper< INDEX, ARGS... >::type;
+
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    if( INDEX + 1 >= SIZE )
+      return signature< current_type >::name();
+    return signature< current_type >::name() + ", " + signature_tuple_helper< INDEX + 1, SIZE, ARGS... >::name();
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return signature< current_type >::sig() + signature_tuple_helper< INDEX + 1, SIZE, ARGS... >::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::tuple< ARGS... >& args )
+  {
+    signature< current_type >::set( iter, std::get< INDEX >( args ) );
+    signature_tuple_helper< INDEX + 1, SIZE, ARGS... >::set( iter, args );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::tuple< ARGS... >& args )
+  {
+    return signature< current_type >::get( iter, std::get< INDEX >( args ) ) &&
+           signature_tuple_helper< INDEX + 1, SIZE, ARGS... >::get( iter, args );
+  }
+};
+
+/**
+ * @brief Helper class to marshall tuples
+ *
+ * This class marks end of the tuple marshalling. Members of this class are called
+ * when INDEX value is equal to SIZE.
+ */
+template < size_t SIZE, typename... ARGS >
+struct signature_tuple_helper< SIZE, SIZE, ARGS... >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::tuple< ARGS... >& args )
+  {
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::tuple< ARGS... >& args )
+  {
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling tuple of values
+ *
+ * This class marshalls tuple of values. This represents
+ * DBUS struct typle, encoded with character 'r'
+ */
+template < typename... ARGS >
+struct signature< std::tuple< ARGS... > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "tuple<" + signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::name() + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "(" + signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::sig() + ")";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::tuple< ARGS... >& args )
+  {
+    auto entry = DBUS_W->eldbus_message_iter_container_new_impl( iter, 'r', "");
+    signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::set( entry, args );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::tuple< ARGS... >& args )
+  {
+    auto entry = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, 'r' );
+    if (!entry) return false;
+    return signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::get( entry, args );
+  }
+};
+
+/**
+ * @brief Signature class for marshalling ValueOrError template type
+ *
+ * ValueOrError template type is used to marshall list of values passed to
+ * DBUS (or received from) at the "top" level. For example ss(s) is represented as
+ * \code{.cpp} ValueOrError<std::string, std::string, std::tuple<std::string>> \endcode
+ * While (ss(s)) is represented as
+ * \code{.cpp} std::tuple<std::string, std::string, std::tuple<std::string>> \endcode
+ * or
+ * \code{.cpp} ValueOrError<std::tuple<std::string, std::string, std::tuple<std::string>>> \endcode
+ */
+template < typename... ARGS >
+struct signature< ValueOrError< ARGS... > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "ValueOrError<" + signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::name() + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const ValueOrError< ARGS... >& args )
+  {
+    signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::set( iter, args.getValues() );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, ValueOrError< ARGS... >& args )
+  {
+    return signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::get( iter, args.getValues() );
+  }
+};
+
+/**
+ * @brief Signature class for marshalling ValueOrError<void> type
+ */
+template <>
+struct signature< ValueOrError< void > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "ValueOrError<void>";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const ValueOrError< void >& args )
+  {
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, ValueOrError< void >& args )
+  {
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling ValueOrError<> type
+ */
+template <>
+struct signature< ValueOrError<> >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "ValueOrError<>";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const ValueOrError<>& args )
+  {
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, ValueOrError<>& args )
+  {
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling pair of types
+ */
+template < typename A, typename B >
+struct signature< std::pair< A, B > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "pair<" + signature_tuple_helper< 0, 2, A, B >::name() + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "(" + signature_tuple_helper< 0, 2, A, B >::sig() + ")";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::pair< A, B >& ab, bool dictionary = false )
+  {
+    auto entry = DBUS_W->eldbus_message_iter_container_new_impl( iter, dictionary ? 'e' : 'r', "");
+    signature_tuple_helper< 0, 2, A, B >::set( entry, ab );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::pair< A, B >& ab )
+  {
+    auto entry = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, 'r' );
+    if (!entry) {
+      entry = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, '{' );
+      if (!entry) return false;
+    }
+
+    std::tuple< A, B > ab_tmp;
+    auto z = signature_tuple_helper< 0, 2, A, B >::get( entry, ab_tmp );
+    if( z )
+    {
+      ab.first = std::move( std::get< 0 >( ab_tmp ) );
+      ab.second = std::move( std::get< 1 >( ab_tmp ) );
+    }
+    return z;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling std::vector template type
+ *
+ * This marshals container's content as DBUS a ascii character type code.
+ */
+template < typename A >
+struct signature< std::vector< A > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "vector<" + signature< A >::name() + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "a" + signature< A >::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::vector< A >& v )
+  {
+    auto lst = DBUS_W->eldbus_message_iter_container_new_impl( iter, 'a', signature< A >::sig());
+    bart_assert( lst );
+    for( auto& a : v )
+    {
+      signature< A >::set( lst, a );
+    }
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::vector< A >& v )
+  {
+    auto s = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, 'a' );
+    if (!s) return false;
+    v.clear();
+    A a;
+    while( signature< A >::get( s, a ) )
+      v.push_back( std::move( a ) );
+
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling std::array template type
+ *
+ * This marshals container's content as DBUS a ascii character type code.
+ */
+template < typename A, size_t N >
+struct signature< std::array< A, N > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "array<" + signature< A >::name() + ", " + std::to_string( N ) + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "a" + signature< A >::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::array< A, N >& v )
+  {
+    auto lst = DBUS_W->eldbus_message_iter_container_new_impl( iter, 'a', signature< A >::sig());
+    bart_assert( lst );
+    for( auto& a : v )
+    {
+      signature< A >::set( lst, a );
+    }
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::array< A, N >& v )
+  {
+    auto s = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, 'a' );
+    if ( !s )
+      return false;
+    for( auto& a : v )
+    {
+      if( !signature< A >::get( s, a ) )
+        return false;
+    }
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling EldbusVariant type
+ *
+ * This marshals variant's content as DBUS v ascii character type code.
+ */
+template < typename A >
+struct signature< EldbusVariant< A > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "variant<" + signature< A >::name() + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "v";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const EldbusVariant< A >& v )
+  {
+    set( iter, v.value );
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const A& v )
+  {
+    auto var = DBUS_W->eldbus_message_iter_container_new_impl( iter, 'v', signature< A >::sig());
+    signature< A >::set( var, v );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, EldbusVariant< A >& v )
+  {
+    auto s = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, 'v' );
+    if( !s )
+      return false;
+    return signature< A >::get( s, v.value );
+  }
+};
+
+/**
+ * @brief Signature class for marshalling std::unordered_map template type
+ *
+ * This marshals container's content as DBUS {} ascii character type code.
+ * Note, that library doesnt check, if the key is basic type, as DBUS
+ * specification mandates.
+ * User can always exchange std::unordered_map for std::map and the reverse.
+ * User can receive such values as std::vector of std::pair<key, value> values.
+ * Order of such values is unspecified.
+ */
+template < typename A, typename B >
+struct signature< std::unordered_map< A, B > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "unordered_map<" + signature< A >::name() + ", " + signature< B >::name() + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "a{" + signature_tuple_helper< 0, 2, A, B >::sig() + "}";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::unordered_map< A, B >& v )
+  {
+    auto sig = "{" + signature_tuple_helper< 0, 2, A, B >::sig() + "}";
+    auto lst = DBUS_W->eldbus_message_iter_container_new_impl( iter, 'a', sig);
+    bart_assert( lst );
+    for( auto& a : v )
+    {
+      signature< std::pair< A, B > >::set( lst, a, true );
+    }
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::unordered_map< A, B >& v )
+  {
+    auto s = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, 'a' );
+    v.clear();
+    if( !s )
+      return false;
+    std::pair< A, B > a;
+    while( signature< std::pair< A, B > >::get( s, a ) )
+      v.insert( std::move( a ) );
+    return true;
+  }
+};
+
+/**
+ * @brief Signature class for marshalling std::unordered_map template type
+ *
+ * This marshals container's content as DBUS {} ascii character type code.
+ * Note, that library doesnt check, if the key is basic type, as DBUS
+ * specification mandates.
+ * User can always exchange std::unordered_map for std::map and the reverse.
+ * User can receive such values as std::vector of std::pair<key, value> values.
+ * Order of such values is unspecified.
+ */
+template < typename A, typename B >
+struct signature< std::map< A, B > >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "map<" + signature< A >::name() + ", " + signature< B >::name() + ">";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return "a{" + signature_tuple_helper< 0, 2, A, B >::sig() + "}";
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const std::map< A, B >& v )
+  {
+    auto sig = "{" + signature_tuple_helper< 0, 2, A, B >::sig() + "}";
+    auto lst = DBUS_W->eldbus_message_iter_container_new_impl( iter, 'a', sig);
+    bart_assert( lst );
+    for( auto& a : v )
+    {
+      signature< std::pair< A, B > >::set( lst, a, true );
+    }
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static bool get( const DBusWrapper::MessageIterPtr &iter, std::map< A, B >& v )
+  {
+    auto s = DBUS_W->eldbus_message_iter_get_and_next_by_type_impl( iter, 'a' );
+    if( !s )
+      return false;
+    std::pair< A, B > a;
+    while( signature< std::pair< A, B > >::get( s, a ) )
+      v.insert( std::move( a ) );
+    return true;
+  }
+};
+
+/**
+ * @brief Signature helper class for marshalling const reference types
+ */
+template < typename A >
+struct signature< const A& >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "const " + signature< A >::name() + "&";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return signature< A >::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const A& v )
+  {
+    signature< A >::set( iter, v );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static void get( const DBusWrapper::MessageIterPtr &iter, A& v )
+  {
+    signature< A >::get( iter, v );
+  }
+};
+
+/**
+ * @brief Signature helper class for marshalling reference types
+ */
+template < typename A >
+struct signature< A& >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return signature< A >::name() + "&";
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return signature< A >::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const A& v )
+  {
+    signature< A >::set( iter, v );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static void get( const DBusWrapper::MessageIterPtr &iter, A& v )
+  {
+    signature< A >::get( iter, v );
+  }
+};
+
+/**
+ * @brief Signature helper class for marshalling const types
+ */
+template < typename A >
+struct signature< const A >
+{
+  /**
+   * @brief Returns name of type marshalled, for informative purposes
+   */
+  static std::string name()
+  {
+    return "const " + signature< A >::name();
+  }
+
+  /**
+   * @brief Returns DBUS' signature of type marshalled
+   */
+  static std::string sig()
+  {
+    return signature< A >::sig();
+  }
+
+  /**
+   * @brief Marshals value v as marshalled type into message
+   */
+  static void set( const DBusWrapper::MessageIterPtr &iter, const A& v )
+  {
+    signature< A >::set( iter, v );
+  }
+
+  /**
+   * @brief Marshals value from marshalled type into variable v
+   */
+  static void get( const DBusWrapper::MessageIterPtr &iter, A& v )
+  {
+    signature< A >::get( iter, v );
+  }
+};
+
+/// \cond
+using CallId = DBusWrapper::CallId;
+
+template < typename ValueType >
+ValueType unpackValues( CallId callId, const DBusWrapper::MessagePtr &msg )
+{
+  auto iter = DBUS_W->eldbus_message_iter_get_impl( msg, false );
+  ValueType r;
+
+  if( iter )
+  {
+    if( !signature< ValueType >::get( iter, r ) )
+    {
+      DBUS_DEBUG( "ValueType is %s", signature< ValueType >::name().c_str() );
+      r = Error{"call " + std::to_string( callId.id ) + ": failed to unpack values, got signature '" +
+                DBUS_W->eldbus_message_signature_get_impl( msg ) + "', expected '" + signature< ValueType >::sig() + "'"};
+    }
+  }
+  else
+  {
+    r = Error{"call " + std::to_string( callId.id ) + ": failed to get iterator"};
+  }
+  return r;
+}
+
+inline void packValues_helper( const DBusWrapper::MessageIterPtr& ) {}
+
+template < typename A, typename... ARGS >
+void packValues_helper( const DBusWrapper::MessageIterPtr &iter, A&& a, ARGS&&... r )
+{
+  signature< A >::set( iter, std::forward< A >( a ) );
+  packValues_helper( iter, std::forward< ARGS >( r )... );
+}
+
+template < typename... ARGS >
+void packValues( CallId callId, const DBusWrapper::MessagePtr &msg, ARGS&&... r )
+{
+  auto iter = DBUS_W->eldbus_message_iter_get_impl( msg, true );
+  packValues_helper( iter, std::forward< ARGS >( r )... );
+}
+
+template < typename >
+struct ReturnType;
+template < typename R, typename... ARGS >
+struct ReturnType< R( ARGS... ) >
+{
+  using type = R;
+};
+
+template < typename R, typename... ARGS >
+struct ReturnType< std::function< R( ARGS... ) > >
+{
+  using type = R;
+};
+
+template < int... >
+struct sequence
+{
+};
+
+template < int N, int... S >
+struct sequence_gen : sequence_gen< N - 1, N - 1, S... >
+{
+};
+
+template < int... S >
+struct sequence_gen< 0, S... >
+{
+  typedef sequence< S... > type;
+};
+
+template < typename C, typename... ARGS >
+struct apply_helper
+{
+  const std::function< C >& c;
+  const std::tuple< ARGS... >& args;
+
+  template < int... S >
+  auto apply_2( sequence< S... > ) const -> decltype( c( std::get< S >( args )... ) )
+  {
+    return c( std::get< S >( args )... );
+  }
+  auto apply_1() const -> decltype( apply_2( typename sequence_gen< sizeof...( ARGS ) >::type() ) )
+  {
+    return apply_2( typename sequence_gen< sizeof...( ARGS ) >::type() );
+  }
+};
+
+template < typename C, typename A, typename... ARGS >
+struct apply_helper_2
+{
+  const std::function< C >& c;
+  const A& a;
+  const std::tuple< ARGS... >& args;
+
+  template < int... S >
+  auto apply_2( sequence< S... > ) const -> decltype( c( a, std::get< S >( args )... ) )
+  {
+    return c( a, std::get< S >( args )... );
+  }
+  auto apply_1() const -> decltype( apply_2( typename sequence_gen< sizeof...( ARGS ) >::type() ) )
+  {
+    return apply_2( typename sequence_gen< sizeof...( ARGS ) >::type() );
+  }
+};
+
+template < typename C, typename... ARGS >
+auto apply( const std::function< C >& c, const std::tuple< ARGS... >& args ) -> typename ReturnType< C >::type
+{
+  apply_helper< C, ARGS... > ah{c, args};
+  return ah.apply_1();
+}
+
+template < typename C, typename D, typename... ARGS >
+auto apply( const std::function< C >& c, const D& d, const std::tuple< ARGS... >& args ) -> typename ReturnType< C >::type
+{
+  apply_helper_2< C, D, ARGS... > ah{c, d, args};
+  return ah.apply_1();
+}
+
+struct ConnectionState
+{
+  DBusWrapper::ConnectionPtr connection;
+  DBusWrapper::ObjectPtr object;
+  DBusWrapper::ProxyPtr proxy, propertiesProxy;
+};
+
+template < typename RETTYPE, typename... ARGS >
+RETTYPE call( CallId callId, const ConnectionState& connectionState, bool property, const std::string& funcName, const ARGS&... args )
+{
+  const auto &proxy = property ? connectionState.propertiesProxy : connectionState.proxy;
+  if( !proxy )
+  {
+    DBUS_DEBUG( "call %d: not initialized", callId.id );
+    return Error{"not initialized"};
+  }
+
+  DBUS_DEBUG( "call %d: calling '%s'", callId.id, funcName.c_str() );
+  auto msg = DBUS_W->eldbus_proxy_method_call_new_impl(proxy, funcName);
+  if( !msg )
+  {
+    DBUS_DEBUG( "call %d: failed", callId.id );
+    return Error{"failed to create message"};
+  }
+
+  detail::packValues( callId, msg, args... );
+  auto reply = DBUS_W->eldbus_proxy_send_and_block_impl( proxy, msg );
+  DBUS_DEBUG( "call %d: calling '%s' done", callId.id, funcName.c_str() );
+  if( !reply )
+  {
+    DBUS_DEBUG( "call %d: failed", callId.id );
+    return Error{"eldbus returned null as reply"};
+  }
+  std::string errname, errmsg;
+  if( DBUS_W->eldbus_message_error_get_impl( reply, errname, errmsg ) )
+  {
+    DBUS_DEBUG( "call %d: %s: %s", callId.id, errname.c_str(), errmsg.c_str() );
+    return Error{errname + ": " + errmsg};
+  }
+  DBUS_DEBUG( "call %d: got reply with signature '%s'", callId.id,
+    DBUS_W->eldbus_message_signature_get_impl( reply ).c_str() );
+  return detail::unpackValues< RETTYPE >( callId, reply );
+}
+
+template < typename RETTYPE, typename... ARGS >
+void asyncCall( CallId callId, const ConnectionState &connectionState,
+                bool property, const std::string& funcName,
+                std::function< void( RETTYPE ) > callback, const ARGS&... args )
+{
+  const auto &proxy = property ? connectionState.propertiesProxy : connectionState.proxy;
+  if( !proxy )
+  {
+    DBUS_DEBUG( "call %d: not initialized", callId.id );
+    callback( Error{"not initialized"} );
+    return;
+  }
+
+  auto msg = DBUS_W->eldbus_proxy_method_call_new_impl( proxy, funcName );
+  if( !msg )
+  {
+    DBUS_DEBUG( "call %d: failed", callId.id );
+    callback( Error{"failed to create message"} );
+    return;
+  }
+
+  detail::packValues( callId, msg, args... );
+  auto pending = DBUS_W->eldbus_proxy_send_impl( proxy, msg, [callback, callId, proxy]( const DBusWrapper::MessagePtr &reply ) {
+        DBUS_DEBUG( "call %d: calling done", callId.id );
+        if( !reply )
+        {
+          DBUS_DEBUG( "call %d: failed", callId.id );
+          callback( Error{"eldbus returned null as reply"} );
+        }
+        else
+        {
+          std::string errname, errmsg;
+          if( DBUS_W->eldbus_message_error_get_impl( reply, errname, errmsg ) )
+          {
+            DBUS_DEBUG( "call %d: %s: %s", callId.id, errname.c_str(), errmsg.c_str() );
+            callback( Error{errname + ": " + errmsg} );
+          }
+          else
+          {
+            DBUS_DEBUG( "call %d: got reply with signature '%s'", callId.id,
+                DBUS_W->eldbus_message_signature_get_impl( reply ).c_str() );
+            callback( detail::unpackValues< RETTYPE >( callId, reply ) );
+          }
+        }
+      }
+    );
+  if( pending )
+  {
+    DBUS_DEBUG( "call %d: call sent", callId.id );
+  }
+  else
+  {
+    DBUS_DEBUG( "call %d: failed to send call", callId.id );
+    callback( Error{"failed to send call"} );
+  }
+}
+
+inline void displayDebugCallInfo( CallId callId, const std::string& funcName, const std::string& info, const std::string& interfaceName )
+{
+  DBUS_DEBUG( "call %d: %s iname = %s fname = %s", callId.id, info.c_str(), interfaceName.c_str(), funcName.c_str() );
+}
+
+inline void displayDebugCallInfoSignal( CallId callId, const std::string& funcName, const std::string& info, const std::string& interfaceName )
+{
+  DBUS_DEBUG( "call %d: %s signal iname = %s fname = %s", callId.id, info.c_str(), interfaceName.c_str(), funcName.c_str() );
+}
+
+inline void displayDebugCallInfoProperty( CallId callId, const std::string& funcName, std::string info, const std::string& interfaceName,
+                                          const std::string& propertyName )
+{
+  DBUS_DEBUG( "call %d: %s iname = %s pname = %s", callId.id, info.c_str(), interfaceName.c_str(), propertyName.c_str() );
+}
+
+using StringStorage = DBusWrapper::StringStorage;
+
+template < typename A, typename... ARGS >
+struct EldbusArgGenerator_Helper
+{
+  static void add( std::vector< std::pair<std::string, std::string> >& r )
+  {
+    auto s = r.size();
+    auto sig = signature< A >::sig();
+    bart_assert( !sig.empty() );
+    auto name = "p" + std::to_string( s + 1 );
+    r.push_back({ std::move(sig), std::move(name) });
+    EldbusArgGenerator_Helper<ARGS...>::add( r );
+  }
+};
+
+template <>
+struct EldbusArgGenerator_Helper< void >
+{
+  static void add( std::vector< std::pair<std::string, std::string> >& )
+  {
+  }
+};
+
+template <>
+struct EldbusArgGenerator_Helper< ValueOrError< void >, void >
+{
+  static void add( std::vector< std::pair<std::string, std::string> >& )
+  {
+  }
+};
+template <>
+struct EldbusArgGenerator_Helper< ValueOrError<>, void >
+{
+  static void add( std::vector< std::pair<std::string, std::string> >& )
+  {
+  }
+};
+
+template < typename... ARGS >
+struct EldbusArgGenerator_Helper< std::tuple< ARGS... > >
+{
+  static void add( std::vector< std::pair<std::string, std::string> >& r )
+  {
+    EldbusArgGenerator_Helper< ARGS..., void >::add( r );
+  }
+};
+
+template < typename RetType >
+struct dbus_interface_return_type_traits
+{
+  using type = ValueOrError< RetType >;
+};
+
+template < typename... ARGS >
+struct dbus_interface_return_type_traits< ValueOrError< ARGS... > >
+{
+  using type = ValueOrError< ARGS... >;
+};
+
+template < typename T >
+struct dbus_interface_traits;
+template < typename RetType, typename... ARGS >
+struct dbus_interface_traits< RetType( ARGS... ) >
+{
+  using Ret = typename dbus_interface_return_type_traits< RetType >::type;
+  using SyncCB = std::function< Ret( ARGS... ) >;
+  using AsyncCB = std::function< void( std::function< void( Ret ) >, ARGS... ) >;
+  using VEArgs = ValueOrError< ARGS... >;
+};
+
+template < typename T >
+struct EldbusArgGenerator_Args;
+template < typename RetType, typename... ARGS >
+struct EldbusArgGenerator_Args< RetType( ARGS... ) >
+{
+  static std::string name()
+  {
+    return signature_tuple_helper< 0, sizeof...( ARGS ), ARGS... >::name();
+  }
+  static std::vector< std::pair<std::string, std::string> > get()
+  {
+    std::vector< std::pair<std::string, std::string> > tmp;
+    EldbusArgGenerator_Helper< ARGS..., void >::add( tmp );
+    return tmp;
+  }
+};
+
+template < typename T >
+struct EldbusArgGenerator_ReturnType;
+template < typename RetType, typename... ARGS >
+struct EldbusArgGenerator_ReturnType< RetType( ARGS... ) >
+{
+  static std::string name()
+  {
+    return signature< RetType >::name();
+  }
+  static std::vector< std::pair<std::string, std::string> > get( )
+  {
+    std::vector< std::pair<std::string, std::string> > tmp;
+    EldbusArgGenerator_Helper< RetType, void >::add( tmp );
+    return tmp;
+  }
+};
+
+template < typename T >
+struct EldbusArgGenerator_ReturnType;
+template < typename... ARGS >
+struct EldbusArgGenerator_ReturnType< void( ARGS... ) >
+{
+  static std::string name()
+  {
+    return "";
+  }
+  static std::vector< std::pair<std::string, std::string> > get( )
+  {
+    return {};
+  }
+};
+/// \endcond
+}
+
+using ConnectionType = DBusWrapper::ConnectionType;
+
+/**
+ * @brief Class representing client's end of DBUS connection
+ *
+ * Allows calling (synchronous and asynchronos) methods on selected interface
+ * Allows (synchronous and asynchronos) setting / getting properties.
+ * Allows registering signals.
+ */
+class DBusClient
+{
+  /// \cond
+  struct ConnectionInfo
+  {
+    std::string interfaceName, busName, pathName;
+  };
+  /// \endcond
+public:
+  /**
+   * @brief Default constructor, creates non-connected object.
+   */
+  DBusClient() = default;
+
+  /**
+   * @brief Connects to dbus choosen by tp, using given arguments
+   *
+   * @param bus_name name of the bus to connect to
+   * @param path_name object's path
+   * @param interface_name interface name
+   */
+  DBusClient( std::string busName_, std::string pathName_, std::string interfaceName_,
+              ConnectionType tp );
+
+  /**
+   * @brief Connects to dbus using connection conn
+   *
+   * @param bus_name name of the bus to connect to
+   * @param path_name object's path
+   * @param interface_name interface name
+   * @param conn connection object from getDBusConnectionByType call
+   */
+  DBusClient( std::string busName_, std::string pathName_, std::string interfaceName_,
+              const DBusWrapper::ConnectionPtr &conn = {} );
+
+  /**
+   * @brief Destructor object.
+   *
+   * All signals added will be disconnected.
+   * All asynchronous calls will be cancelled, their callback's will be called
+   * with failure message.
+   */
+  ~DBusClient() = default;
+  DBusClient( const DBusClient& ) = delete;
+  DBusClient( DBusClient&& ) = default;
+
+  DBusClient& operator=( DBusClient&& ) = default;
+  DBusClient& operator=( const DBusClient& ) = delete;
+
+  /**
+   * @brief bool operator
+   *
+   * Returns true, if object is connected to DBUS
+   */
+  explicit operator bool() const
+  {
+    return bool( connectionState->proxy );
+  }
+
+  /**
+   * @brief Helper class for calling a method
+   *
+   * Template type T defines both arguments sent to the method
+   * and expected values. Receiving different values will be reported as
+   * error. For example:
+   * \code{.cpp} Method<int(float, float)> \endcode
+   * defines method, which takes two arguments (two floats) and return
+   * single value of type int.
+   */
+  template < typename T >
+  struct Method
+  {
+    /// \cond
+    using RetType = typename detail::dbus_interface_traits< T >::Ret;
+    const detail::ConnectionState &connectionState;
+    std::string funcName;
+    std::string info;
+    std::shared_ptr< ConnectionInfo > connectionInfo;
+    /// \endcond
+
+    /**
+     * @brief Executes synchronous call on DBUS's method
+     *
+     * The function returns ValueOrError<...> object, which
+     * contains either received values or error message.
+     *
+     * @param args arguments to pass to the method
+     */
+    template < typename... ARGS >
+    RetType call( const ARGS&... args )
+    {
+      detail::CallId callId;
+      detail::displayDebugCallInfo( callId, funcName, info, connectionInfo->interfaceName );
+      return detail::call< RetType >( callId, connectionState, false, funcName, args... );
+    }
+
+    /**
+     * @brief Executes asynchronous call on DBUS's method
+     *
+     * The function calls callback with either received values or error message.
+     *
+     * @param callback callback functor, which will be called with return value(s) or error message
+     * @param args arguments to pass to the method
+     */
+    template < typename... ARGS >
+    void asyncCall( std::function< void( RetType ) > callback, const ARGS&... args )
+    {
+      detail::CallId callId;
+      detail::displayDebugCallInfo( callId, funcName, info, connectionInfo->interfaceName );
+      detail::asyncCall< RetType >( callId, connectionState, false, funcName, std::move( callback ), args... );
+    }
+  };
+
+  /**
+   * @brief Helper class for calling a property
+   *
+   * Template type T defines type of the value hidden under property.
+   * Note, that library automatically wraps both sent and received value into
+   * DBUS's wrapper type.
+   */
+  template < typename T >
+  struct Property
+  {
+    /// \cond
+    using RetType = typename detail::dbus_interface_return_type_traits< T >::type;
+    using VariantRetType = typename detail::dbus_interface_return_type_traits< EldbusVariant< T > >::type;
+    const detail::ConnectionState &connectionState;
+    std::string propName;
+    std::string info;
+    std::shared_ptr< ConnectionInfo > connectionInfo;
+    /// \endcond
+
+    /**
+     * @brief executes synchronous get on property
+     *
+     * The function returns ValueOrError<...> object, which
+     * contains either received values or error message.
+     */
+    RetType get()
+    {
+      detail::CallId callId;
+      detail::displayDebugCallInfoProperty( callId, "Get", info, connectionInfo->interfaceName, propName );
+      auto z = detail::call< VariantRetType >( callId, connectionState, true, "Get", connectionInfo->interfaceName, propName );
+      if( !z )
+        return z.getError();
+      return {std::get< 0 >( z.getValues() ).value};
+    }
+
+    /**
+     * @brief executes asynchronous get on property
+     *
+     * The function calls callback with either received values or error message.
+     *
+     * @param callback callback functor, which will be called with return value(s) or error message
+     */
+    void asyncGet( std::function< void( RetType ) > callback )
+    {
+      detail::CallId callId;
+      detail::displayDebugCallInfoProperty( callId, "Get", info, connectionInfo->interfaceName, propName );
+      auto cc = [callback]( VariantRetType reply ) {
+        if( reply )
+          callback( std::move( std::get< 0 >( reply.getValues() ).value ) );
+        else
+          callback( reply.getError() );
+      };
+      detail::asyncCall< VariantRetType >( callId, connectionState, true, "Get", std::move( cc ), connectionInfo->interfaceName, propName );
+    }
+
+    /**
+     * @brief executes synchronous set on property
+     *
+     * The function returns ValueOrError<void> object, with
+     * possible error message.
+     */
+    ValueOrError< void > set( const T& r )
+    {
+      detail::CallId callId;
+      detail::displayDebugCallInfoProperty( callId, "Set", info, connectionInfo->interfaceName, propName );
+      EldbusVariant< T > variantValue{std::move( r )};
+      return detail::call< ValueOrError< void > >( callId, connectionState, true, "Set", connectionInfo->interfaceName, propName, variantValue );
+    }
+
+    /**
+     * @brief executes asynchronous get on property
+     *
+     * The function calls callback with either received values or error message.
+     *
+     * @param callback callback functor, which will be called with return value(s) or error message
+     */
+    void asyncSet( std::function< void( ValueOrError< void > ) > callback, const T& r )
+    {
+      detail::CallId callId;
+      detail::displayDebugCallInfoProperty( callId, "Set", info, connectionInfo->interfaceName, propName );
+      EldbusVariant< T > variantValue{std::move( r )};
+      detail::asyncCall< ValueOrError< void > >( callId, connectionState, true, "Set", std::move( callback ), connectionInfo->interfaceName, propName, variantValue );
+    }
+  };
+
+  /**
+   * @brief Constructs Property<...> object for calling properties
+   *
+   * The function constructs and returns proxy object for calling property.
+   *
+   * @param propName property name to set and / or query
+   */
+  template < typename PropertyType >
+  Property< PropertyType > property( std::string propName )
+  {
+    return Property< PropertyType >{*connectionState, std::move( propName ), info, connectionInfo};
+  }
+
+  /**
+   * @brief Constructs Method<...> object for calling methods
+   *
+   * The function constructs and returns proxy object for calling method.
+   *
+   * @param funcName function name to call
+   */
+  template < typename MethodType >
+  Method< MethodType > method( std::string funcName )
+  {
+    return Method< MethodType >{*connectionState, std::move( funcName ), info, connectionInfo};
+  }
+
+  /**
+   * @brief Registers notification callback, when property has changed
+   *
+   * The callback will be called with new value, when property's value has changed.
+   * Note, that template type V must match expected type, otherwise undefined behavior will occur,
+   * there's no check for this.
+   */
+  template < typename V >
+  void addPropertyChangedEvent( std::string propertyName, std::function< void( V ) > callback )
+  {
+    detail::CallId callId;
+    detail::displayDebugCallInfoSignal( callId, propertyName, info, connectionInfo->interfaceName );
+    DBUS_DEBUG( "call %d: adding property", callId.id );
+    auto &cI = this->connectionInfo;
+    DBUS_W->add_property_changed_event_listener_impl(connectionState->proxy, cI->interfaceName, propertyName,
+      [callback]( const _Eina_Value *newValue ) {
+      V val = 0;
+      if( !getFromEinaValue( newValue, &val ) )
+      {
+        DBUS_DEBUG( "unable to get property's value" );
+        return;
+      }
+      callback( val );
+    });
+  }
+
+  /**
+   * @brief Registers callback on the DBUS' signal
+   *
+   * The function registers callback signalName. When signal comes, callback will be called.
+   * Callback object will exists as long as signal is registered. You can unregister signal
+   * by destroying DBusClient object.
+   *
+   * @param signalName name of the signal to register
+   * @param callback callback to call
+   */
+  template < typename SignalType >
+  void addSignal( std::string signalName, std::function< SignalType > callback )
+  {
+    detail::CallId callId;
+    detail::displayDebugCallInfoSignal( callId, signalName, info, connectionInfo->interfaceName );
+    DBUS_W->eldbus_proxy_signal_handler_add_impl( connectionState->proxy, signalName,
+      [callId, callback, signalName]( const DBusWrapper::MessagePtr &msg ) -> void {
+        std::string errname, aux;
+        if( DBUS_W->eldbus_message_error_get_impl( msg, errname, aux ) )
+        {
+          DBUS_DEBUG( "call %d: Eldbus error: %s %s", callId.id, errname.c_str(), aux.c_str() );
+          return;
+        }
+        DBUS_DEBUG( "call %d: received signal with signature '%s'", callId.id, DBUS_W->eldbus_message_signature_get_impl( msg ).c_str() );
+        using ParamsType = typename detail::dbus_interface_traits< SignalType >::VEArgs;
+        auto params = detail::unpackValues< ParamsType >( callId, msg );
+        if( !params )
+        {
+          DBUS_DEBUG( "call %d: failed: %s", callId.id, params.getError().message.c_str() );
+          return;
+        }
+        try
+        {
+          detail::apply( callback, params.getValues() );
+        }
+        catch( ... )
+        {
+          DBUS_DEBUG( "unhandled exception" );
+          bart_assert( 0 );
+        }
+      });
+  }
+
+private:
+  /// \cond
+  std::unique_ptr<detail::ConnectionState> connectionState{ new detail::ConnectionState };
+  std::string info;
+  std::shared_ptr< ConnectionInfo > connectionInfo;
+
+  static bool getFromEinaValue(const _Eina_Value *v, void *dst);
+  /// \endcond
+};
+
+/**
+ * @brief Helper class describing DBUS's server interface
+ *
+ */
+class DBusInterfaceDescription
+{
+  friend class DBusServer;
+
+public:
+  /// \cond
+  using MethodInfo = DBusWrapper::MethodInfo;
+  using SignalInfo = DBusWrapper::SignalInfo;
+  using PropertyInfo = DBusWrapper::PropertyInfo;
+  using SignalId = DBusWrapper::SignalId;
+  /// \endcond
+
+  /**
+   * @brief Creates empty interface description with given name
+   *
+   * @param interfaceName name of the interface
+   */
+  DBusInterfaceDescription( std::string interfaceName );
+
+  /**
+   * @brief adds new, synchronous method to the interface
+   *
+   * When method memberName is called on DBUS, callback functor will be called
+   * with values received from DBUS. callback won't be called, if method was
+   * called with invalid signature. Value returned from functor (or error message)
+   * will be marshalled back to the caller.
+   *
+   * Template type T defines both arguments sent to the method
+   * and expected values. Receiving different values will be reported as
+   * error. For example:
+   * \code{.cpp} Method<int(float, float)> \endcode
+   * defines method, which takes two arguments (two floats) and return
+   * single value of type int.
+   *
+   * @param memberName name of the method
+   * @param callback functor, which will be called
+   */
+  template < typename T >
+  void addMethod( const std::string& memberName, typename detail::dbus_interface_traits< T >::SyncCB callback )
+  {
+    detail::CallId callId;
+    MethodInfo mi;
+    methods.push_back( std::move( mi ) );
+    auto& z = methods.back();
+    z.in = detail::EldbusArgGenerator_Args< T >::get( );
+    z.out = detail::EldbusArgGenerator_ReturnType< T >::get( );
+    z.memberName = memberName;
+    DBUS_DEBUG( "call %d: method %s, in %s, out %s", callId.id, memberName.c_str(),
+                detail::EldbusArgGenerator_Args< T >::name().c_str(),
+                detail::EldbusArgGenerator_ReturnType< T >::name().c_str() );
+    z.callback = construct< T >( callId, callback );
+    z.id = callId;
+  }
+
+  /**
+   * @brief adds new, synchronous property to the interface
+   *
+   * When property memberName is called on DBUS, respective callback functor will be called
+   * with values received from DBUS. callback won't be called, if method was
+   * called with invalid signature. Value returned from functor (or error message)
+   * will be marshalled back to the caller.
+   *
+   * Template type T defines type of the value hidden under property.
+   * Note, that library automatically wraps both sent and received value into
+   * DBUS's wrapper type.
+   *
+   * @param memberName name of the method
+   * @param getter functor, which will be called when property is being read
+   * @param setter functor, which will be called when property is being set
+   */
+  template < typename T >
+  void addProperty( const std::string& memberName, std::function< ValueOrError< T >() > getter, std::function< ValueOrError< void >( T ) > setter )
+  {
+    properties.push_back( {} );
+    auto& z = properties.back();
+    z.memberName = memberName;
+    z.typeSignature = detail::signature< T >::sig();
+    if( getter )
+    {
+      detail::CallId getterId;
+      z.getterId = getterId;
+      DBUS_DEBUG( "call %d: property %s (get) type %s", getterId.id, memberName.c_str(), detail::signature< T >::name().c_str() );
+      z.getCallback = [=]( const DBusWrapper::MessagePtr &src, const DBusWrapper::MessageIterPtr &dst ) -> std::string {
+        try
+        {
+          auto v = detail::apply( getter, std::tuple<>{} );
+          if( v )
+          {
+            detail::signature< T >::set( dst, std::get< 0 >( v.getValues() ) );
+            DBUS_DEBUG( "call %d: success", getterId.id );
+            return "";
+          }
+          DBUS_DEBUG( "call %d: failed: %s", getterId.id, v.getError().message.c_str() );
+          return v.getError().message;
+        }
+        catch( std::exception& e )
+        {
+          return std::string( "unhandled exception (" ) + e.what() + ")";
+        }
+        catch( ... )
+        {
+          return "unhandled exception";
+        }
+      };
+    }
+    if( setter )
+    {
+      detail::CallId setterId;
+      z.setterId = setterId;
+      DBUS_DEBUG( "call %d: property %s (set) type %s", setterId.id, memberName.c_str(), detail::signature< T >::name().c_str() );
+      z.setCallback = [=]( const DBusWrapper::MessagePtr &src, const DBusWrapper::MessageIterPtr &src_iter ) -> std::string {
+        std::tuple< T > value;
+        auto src_signature = DBUS_W->eldbus_message_iter_signature_get_impl( src_iter );
+        if( detail::signature< T >::get( src_iter, std::get< 0 >( value ) ) )
+        {
+          try
+          {
+            auto v = detail::apply( setter, std::move( value ) );
+            if( v )
+            {
+              DBUS_DEBUG( "call %d: success", setterId.id );
+              return "";
+            }
+            DBUS_DEBUG( "call %d: failed: %s", setterId.id, v.getError().message.c_str() );
+            return v.getError().message;
+          }
+          catch( std::exception& e )
+          {
+            return std::string( "unhandled exception (" ) + e.what() + ")";
+          }
+          catch( ... )
+          {
+            return "unhandled exception";
+          }
+        }
+        DBUS_DEBUG( "call %d: failed to unpack values, got signature '%s', expected '%s'", setterId.id,
+                    src_signature.c_str(), detail::signature< T >::sig().c_str() );
+        return "call " + std::to_string( setterId.id ) + ": failed to unpack values, got signature '" +
+                     src_signature + "', expected '" + detail::signature< T >::sig() + "'";
+      };
+    }
+  }
+
+  /**
+   * @brief adds new signal to the interface
+   *
+   * Template types ARGS defines values, which will be emited with the signal
+   *
+   * @param memberName name of the method
+   */
+  template < typename... ARGS >
+  SignalId addSignal( const std::string& memberName )
+  {
+    detail::CallId callId;
+    signals.push_back( {} );
+    auto& z = signals.back();
+    z.memberName = memberName;
+    z.args = detail::EldbusArgGenerator_Args< void( ARGS... ) >::get( DBUS_W->Strings );
+    z.id = callId;
+    DBUS_DEBUG( "call %d: signal %s", callId.id, memberName.c_str() );
+    return SignalId{callId};
+  }
+
+private:
+  /// \cond
+  std::vector< MethodInfo > methods;
+  std::vector< PropertyInfo > properties;
+  std::vector< SignalInfo > signals;
+  std::string interfaceName;
+
+  template < typename T >
+  std::function< DBusWrapper::MessagePtr( const DBusWrapper::MessagePtr &msg ) > construct( detail::CallId callId,
+                                                                           typename detail::dbus_interface_traits< T >::SyncCB callback )
+  {
+    using VEArgs = typename detail::dbus_interface_traits< T >::VEArgs;
+    return [=]( const DBusWrapper::MessagePtr &msg ) -> DBusWrapper::MessagePtr {
+      DBUS_DEBUG( "call %d: entering", callId.id );
+      DBusWrapper::MessagePtr ret = {};
+      auto args = detail::unpackValues< VEArgs >( callId, msg );
+      if( args )
+      {
+        try
+        {
+          auto v = detail::apply( callback, std::move( args.getValues() ) );
+          if( v )
+          {
+            DBUS_DEBUG( "call %d: success", callId.id );
+            ret = DBUS_W->eldbus_message_method_return_new_impl( msg );
+            detail::packValues( callId, ret, v );
+          }
+          else
+          {
+            DBUS_DEBUG( "call %d: failed: %s", callId.id, v.getError().message.c_str() );
+            ret = DBUS_W->eldbus_message_error_new_impl( msg, "org.freedesktop.DBus.Error.Failed", v.getError().message );
+          }
+        }
+        catch( std::exception& e )
+        {
+          auto txt = std::string( "unhandled exception (" ) + e.what() + ")";
+          DBUS_DEBUG( "call %d: failed: %s", callId.id, txt.c_str() );
+          ret = DBUS_W->eldbus_message_error_new_impl( msg, "org.freedesktop.DBus.Error.Failed", txt );
+        }
+        catch( ... )
+        {
+          DBUS_DEBUG( "call %d: failed: %s", callId.id, "unhandled exception" );
+          ret = DBUS_W->eldbus_message_error_new_impl( msg, "org.freedesktop.DBus.Error.Failed", "unhandled exception" );
+        }
+      }
+      else
+      {
+        std::ostringstream err;
+        err << "expected signature '" << detail::signature< VEArgs >::sig() << "', got '" << DBUS_W->eldbus_message_signature_get_impl( msg ) << "'";
+        auto str = err.str();
+        DBUS_DEBUG( "call %d: failed: %s", callId.id, str.c_str() );
+        ret = DBUS_W->eldbus_message_error_new_impl( msg, "org.freedesktop.DBus.Error.InvalidArgs", str );
+      }
+      return ret;
+    };
+  }
+  /// \endcond
+};
+
+/**
+ * @brief Class representing server's end of DBUS connection
+ *
+ * Allows listening (synchronously and asynchronosly) on methods on selected interface
+ * Allows listening (synchronously and asynchronosly) on setting / getting properties.
+ * Allows emiting signals.
+ */
+class DBusServer
+{
+public:
+  /**
+   * @brief Constructs non-connected dbus server.
+   */
+  DBusServer() = default;
+
+  /**
+   * @brief Constructs dbus server on either system or user dbus connection.
+   */
+  DBusServer( ConnectionType tp );
+
+  /**
+   * @brief Constructs dbus server on connection from getDBusConnectionByType
+   */
+  DBusServer( const DBusWrapper::ConnectionPtr &conn );
+
+  /**
+   * @brief Destructor
+   *
+   * Destructor will properly destroy everything. Destructor will cancel
+   * pending replies.
+   */
+  ~DBusServer() = default;
+
+  DBusServer( const DBusServer& ) = delete;
+  DBusServer( DBusServer&& ) = default;
+
+  DBusServer& operator=( DBusServer&& ) = default;
+  DBusServer& operator=( const DBusServer& ) = delete;
+
+  /**
+   * @brief Registers interface on given path name
+   *
+   * @param pathName path object to register interface on.
+   * @param dscr
+   * @param fallback
+   */
+  void addInterface( const std::string& pathName, DBusInterfaceDescription& dscr, bool fallback = false );
+
+  /**
+   * @brief Gets bus name of the current connection (must be connected)
+   */
+  std::string getBusName() const;
+
+  /**
+   * @brief Returns connection object for this dbus server object
+   *
+   * @return connection object
+   */
+  DBusWrapper::ConnectionPtr getConnection();
+
+  /**
+   * @brief Emits signal
+   *
+   * Emits signal based only on data passed to the function
+   *
+   * @param signal identifier of the signal
+   * @param args values to emit
+   */
+  template < typename... ARGS >
+  void emit2( const std::string& path, const std::string& interfaceName,
+              const std::string& signalName, const ARGS&... args )
+  {
+    auto msg = DBUS_W->eldbus_message_signal_new_impl( path, interfaceName, signalName );
+    detail::CallId id;
+    detail::packValues( id, msg, args... );
+    DBUS_W->eldbus_connection_send_impl( connection, msg );
+  }
+
+  /**
+   * @brief Returns current object path, when handling call to property / method
+   *
+   * User can call this function from inside callback used to handle property / method calls.
+   * It will retrieve object's path used in the call. Note, that in asynchronous handling
+   * of those calls user need to retrieve and store the current object / current connection
+   * as the value will change at the moment user's callback handling will exit. For example:
+   * \code{.cpp}
+   * DBusInterfaceDescription interface{"name"};
+   * auto handler_later = [](std::function<void(void)> done_cb) {
+   *   // process something later on
+   *   DBusServer::getCurrentObjectPath(); // this will return empty string
+   * };
+   * interface.addAsyncMethod<void()>("m", [=](std::function<void(void)> done_cb) {
+   *   DBusServer::getCurrentObjectPath(); // this will current object's path
+   *
+   *   // do some processing later on and call done_cb, when it's done
+   *   register_to_call_sometime_later_on(std::move(done_cb));
+   * };
+   * \endcode
+   */
+  static std::string getCurrentObjectPath() { return currentObjectPath; }
+
+  /**
+   * @brief Returns current connection object, when handling call to property / method
+   *
+   * User can call this function from inside callback used to handle property / method calls.
+   * It will retrieve object's path used in the call. Note, that in asynchronous handling
+   * of those calls user need to retrieve and store the current object / current connection
+   * as the value will change at the moment user's callback handling will exit. For example:
+   * \code{.cpp}
+   * DBusInterfaceDescription interface{"name"};
+   * auto handler_later = [](std::function<void(void)> done_cb) {
+   *   // process something later on
+   *   DBusServer::getCurrentObjectPath(); // this will return empty string
+   * };
+   * interface.addAsyncMethod<void()>("m", [=](std::function<void(void)> done_cb) {
+   *   DBusServer::getCurrentObjectPath(); // this will current object's path
+   *
+   *   // do some processing later on and call done_cb, when it's done
+   *   register_to_call_sometime_later_on(std::move(done_cb));
+   * };
+   * \endcode
+   */
+  static const DBusWrapper::ConnectionPtr &getCurrentConnection() { return currentConnection; }
+
+  /// \cond
+  class CurrentObjectSetter
+  {
+  public:
+    CurrentObjectSetter( DBusWrapper::ConnectionPtr con, std::string path )
+    {
+      currentObjectPath = std::move(path);
+      currentConnection = std::move( con );
+    }
+    ~CurrentObjectSetter()
+    {
+      currentObjectPath = "";
+      currentConnection = {};
+    }
+    CurrentObjectSetter( const CurrentObjectSetter& ) = delete;
+    CurrentObjectSetter( CurrentObjectSetter&& ) = delete;
+    void operator=( const CurrentObjectSetter& ) = delete;
+    void operator=( CurrentObjectSetter&& ) = delete;
+  };
+  /// \endcond
+
+private:
+  /// \cond
+  DBusWrapper::ConnectionPtr connection;
+  struct DestructorObject {
+    std::vector<std::function<void()>> destructors;
+    ~DestructorObject() {
+      for(auto &a : destructors) a();
+    }
+  };
+
+  std::unique_ptr<DestructorObject> destructorObject { new DestructorObject() };
+  static thread_local std::string currentObjectPath;
+  static thread_local DBusWrapper::ConnectionPtr currentConnection;
+
+  /// \endcond
+};
+
+/// \cond
+DBusWrapper::ConnectionPtr getDBusConnectionByType( ConnectionType tp );
+DBusWrapper::ConnectionPtr getDBusConnectionByName( const std::string& name );
+std::string getConnectionName( const DBusWrapper::ConnectionPtr& );
+/// \endcond
+}
+
+/// \cond
+namespace std
+{
+template < size_t INDEX, typename... ARGS >
+inline auto get( DBus::ValueOrError< ARGS... >& v ) -> decltype( std::get< INDEX >( v.getValues() ) ) &
+{
+  return std::get< INDEX >( v.getValues() );
+}
+
+template < size_t INDEX, typename... ARGS >
+inline auto get( const DBus::ValueOrError< ARGS... >& v ) -> decltype( std::get< INDEX >( v.getValues() ) )
+{
+  return std::get< INDEX >( v.getValues() );
+}
+}
+/// \endcond
+
+#endif // DALI_INTERNAL_ACCESSIBILITY_BRIDGE_DBUS_H
diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Accessible.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Accessible.cpp
new file mode 100644 (file)
index 0000000..9b103e8
--- /dev/null
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2017 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.
+ *
+ */
+
+// Need to override adaptor classes for toolkit test harness, so include
+// test harness headers before dali headers.
+#include <dali-toolkit-test-suite-utils.h>
+
+#include <dali.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+#include <dali/devel-api/adaptor-framework/accessibility-impl.h>
+
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
+void utc_dali_toolkit_accessibility_accessible_startup(void)
+{
+  test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
+}
+
+void utc_dali_toolkit_accessibility_accessible_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+int utcDaliAccessibilityCheckBoxButtonGetStates(void)
+{
+  ToolkitTestApplication application;
+
+  auto check_box_button = Toolkit::CheckBoxButton::New();
+  auto q = Dali::Accessibility::Accessible::Get( check_box_button );
+  DALI_TEST_CHECK( q );
+  auto states = q->GetStates();
+  DALI_TEST_EQUALS( (int) states[ Dali::Accessibility::State::SELECTABLE ], (int) true, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityCheckLabelText(void)
+{
+  ToolkitTestApplication application;
+
+  auto check_box_button = Toolkit::CheckBoxButton::New();
+  //check_box_button.SetLabelText( "button" );
+  check_box_button.SetProperty(Toolkit::Button::Property::LABEL, "button");
+  auto q = Dali::Accessibility::Accessible::Get( check_box_button );
+  DALI_TEST_CHECK( q );
+  DALI_TEST_EQUALS( q->GetName(), "button", TEST_LOCATION );
+
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Controls-BridgeUp.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Controls-BridgeUp.cpp
new file mode 100644 (file)
index 0000000..c68e84f
--- /dev/null
@@ -0,0 +1,923 @@
+#include <dali-toolkit-test-suite-utils.h>
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.h>
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+#include <dali/devel-api/adaptor-framework/accessibility-impl.h>
+#include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
+#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/controls/popup/popup.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/devel-api/common/stage.h>
+#include <cstdlib>
+
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
+using namespace Dali::Toolkit;
+
+void utc_dali_accessibility_controls_bridge_up_startup(void)
+{
+  test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
+}
+
+void utc_dali_accessibility_controls_bridge_up_cleanup(void)
+{
+  test_return_value = TET_PASS;
+  //DBusWrapper::Install({}) is a de-install
+  DBusWrapper::Install({});
+}
+
+namespace Dali {
+  namespace Accessibility {
+    std::ostream & operator<< (std::ostream & stream, const Address & address)
+    {
+      stream << address.ToString();
+      return stream;
+    }
+  }
+}
+
+int UtcDaliControlAccessibilityRaiseBridge(void)
+{
+  DALI_TEST_CHECK(!Accessibility::IsUp());
+
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC(true);
+
+  DALI_TEST_CHECK(Accessibility::IsUp());
+
+  // auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
+  // for(auto &a : wr->daliMethods) {
+  //   const char *mt;
+  //   if (std::get<3>(a.first) == MethodType::Method) mt = "MethodType::Method";
+  //   else if (std::get<3>(a.first) == MethodType::Getter) mt = "MethodType::Getter";
+  //   else if (std::get<3>(a.first) == MethodType::Setter) mt = "MethodType::Setter";
+  //   else assert(0);
+  //   printf("%s %s %s %s\n", std::get<0>(a.first).c_str(), std::get<1>(a.first).c_str(), std::get<2>(a.first).c_str(), mt);
+  // }
+
+  Dali::Accessibility::TestEnableSC(false);
+
+  DALI_TEST_CHECK(!Accessibility::IsUp());
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityName(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Control::New();
+  Stage::GetCurrent().Add( control );
+
+  auto q = Dali::Accessibility::Accessible::Get( control );
+  DALI_TEST_CHECK( q );
+
+  DALI_TEST_EQUALS( "" , q->GetName(), TEST_LOCATION );
+
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_NAME, "Accessibility_Name" );
+  DALI_TEST_EQUALS( "Accessibility_Name" , q->GetName(), TEST_LOCATION );
+  DALI_TEST_EQUALS( control.GetProperty( DevelControl::Property::ACCESSIBILITY_NAME ).Get< std::string >() , "Accessibility_Name", TEST_LOCATION );
+
+  DevelControl::AccessibilityGetNameSignal(control).Connect( [] (std::string &accessibility_name) {
+    accessibility_name = "Accessibility_Name_With_Callback"; } );
+
+  DALI_TEST_EQUALS( "Accessibility_Name_With_Callback" , q->GetName(), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC(true);
+
+  DALI_TEST_EQUALS( "Accessibility_Name_With_Callback" , TestGetName( q->GetAddress()), TEST_LOCATION );
+
+  //TODO test emission of name change signal
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityDescription(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Control::New();
+
+  auto q = Dali::Accessibility::Accessible::Get( control );
+  DALI_TEST_CHECK( q );
+
+  DALI_TEST_EQUALS( "" , q->GetDescription(), TEST_LOCATION );
+
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_DESCRIPTION, "Accessibility_Description" );
+  DALI_TEST_EQUALS( "Accessibility_Description" , q->GetDescription(), TEST_LOCATION );
+
+  auto property = control.GetProperty( DevelControl::Property::ACCESSIBILITY_DESCRIPTION ).Get<std::string>();
+  DALI_TEST_EQUALS( "Accessibility_Description", property, TEST_LOCATION );
+
+  DevelControl::AccessibilityGetDescriptionSignal(control).Connect( [] (std::string &accessibility_description) {
+    accessibility_description = "Accessibility_Description_With_Callback"; } );
+
+  DALI_TEST_EQUALS( "Accessibility_Description_With_Callback" , q->GetDescription(), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  DALI_TEST_EQUALS( "Accessibility_Description_With_Callback" , TestGetDescription( q->GetAddress()), TEST_LOCATION );
+
+  //TODO test emission of description change signal
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityRole(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Control::New();
+  auto role_unknown = Dali::Accessibility::Role::UNKNOWN;
+  auto role_pushbutton = Dali::Accessibility::Role::PUSH_BUTTON;
+
+  DALI_TEST_EQUALS( role_unknown,control.GetProperty( DevelControl::Property::ACCESSIBILITY_ROLE ).Get< Dali::Accessibility::Role >(), TEST_LOCATION );
+
+  auto q = Dali::Accessibility::Accessible::Get( control );
+  DALI_TEST_EQUALS( role_unknown , q->GetRole(), TEST_LOCATION);
+  DALI_TEST_EQUALS( "unknown" , q->GetRoleName(), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( true );
+  DALI_TEST_CHECK( q );
+  DALI_TEST_EQUALS( static_cast< uint32_t >( role_unknown ), TestGetRole( q->GetAddress() ), TEST_LOCATION );
+  DALI_TEST_EQUALS( "unknown" , TestGetRoleName( q->GetAddress() ), TEST_LOCATION );
+  DALI_TEST_EQUALS( "unknown" , TestGetLocalizedRoleName( q->GetAddress() ), TEST_LOCATION );
+
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_ROLE, role_pushbutton );
+
+  DALI_TEST_EQUALS( static_cast< uint32_t >( role_pushbutton ), TestGetRole( q->GetAddress() ), TEST_LOCATION );
+  DALI_TEST_EQUALS( "push button" ,TestGetRoleName( q->GetAddress() ), TEST_LOCATION );
+  DALI_TEST_EQUALS( "push button" , TestGetLocalizedRoleName( q->GetAddress() ), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  DALI_TEST_EQUALS( role_pushbutton , q->GetRole(), TEST_LOCATION);
+  DALI_TEST_EQUALS( "push button" , q->GetRoleName(), TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityRoleToggleButton(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Dali::Toolkit::ToggleButton::New();
+  auto button = Dali::Accessibility::Role::TOGGLE_BUTTON;
+
+  control.SetProperty(Toolkit::ToggleButton::Property::TOOLTIPS,
+          Property::Array{"option1", "option2"});
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_ROLE, button );
+  auto q = Dali::Accessibility::Accessible::Get( control );
+
+  DALI_TEST_EQUALS( button , q->GetRole(), TEST_LOCATION);
+  DALI_TEST_EQUALS( "toggle button" , q->GetRoleName(), TEST_LOCATION );
+
+  Dali::Accessibility::States states = q->GetStates();
+  DALI_TEST_EQUALS( true , (bool)states[Dali::Accessibility::State::VISIBLE], TEST_LOCATION);
+
+  DALI_TEST_EQUALS( "option1", q->GetDescription(), TEST_LOCATION );
+
+  auto i = dynamic_cast<Dali::Accessibility::Component*>(q);
+  if (i)
+    i->GrabHighlight();
+
+  control.SetProperty( Toolkit::Button::Property::LABEL, "ToggleButton2" );
+  DALI_TEST_EQUALS( "ToggleButton2", TestGetName( q->GetAddress() ), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityButtonLabel(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Dali::Toolkit::PushButton::New();
+  auto button = Dali::Accessibility::Role::PUSH_BUTTON;
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_ROLE, button );
+
+  auto q = Dali::Accessibility::Accessible::Get( control );
+  auto i = dynamic_cast<Dali::Accessibility::Component*>(q);
+
+  if (i)
+    i->GrabHighlight();
+
+  control.SetProperty( Toolkit::Button::Property::LABEL, "Button2" );
+
+  DALI_TEST_EQUALS( "Button2" , TestGetName( q->GetAddress() ), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityState(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Control::New();
+  auto q = Dali::Accessibility::Accessible::Get( control );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto states_by_bridge = Dali::Accessibility::States { TestGetStates( q->GetAddress() )};
+  auto states = DevelControl::GetAccessibilityStates(control);
+  DALI_TEST_CHECK( states_by_bridge == states );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityModal(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Dali::Toolkit::Popup::New();
+  auto q = Dali::Accessibility::Accessible::Get( control );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto states_by_bridge = Dali::Accessibility::States { TestGetStates( q->GetAddress() )};
+  DALI_TEST_CHECK( states_by_bridge[Dali::Accessibility::State::MODAL] );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityHighlightable(void)
+{
+  ToolkitTestApplication application;
+  auto control = Control::New();
+
+  auto noneset = control.GetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE );
+  DALI_TEST_EQUALS( Property::NONE, noneset.GetType(), TEST_LOCATION );
+
+   // negative testcase - trying to set unconvertible value
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, "deadbeef" );
+  noneset = control.GetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE );
+  DALI_TEST_EQUALS( Property::NONE, noneset.GetType(), TEST_LOCATION );
+
+  auto q = Dali::Accessibility::Accessible::Get( control );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto states_by_bridge = Dali::Accessibility::States { TestGetStates( q->GetAddress() )};
+  DALI_TEST_CHECK( !states_by_bridge[ Dali::Accessibility::State::HIGHLIGHTABLE ] );
+
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true );
+  DALI_TEST_EQUALS( Property::BOOLEAN, control.GetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE ).GetType(), TEST_LOCATION );
+  DALI_TEST_EQUALS( true, control.GetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE ).Get< bool >(), TEST_LOCATION );
+
+  states_by_bridge = Dali::Accessibility::States { TestGetStates( q->GetAddress() )};
+  DALI_TEST_CHECK( states_by_bridge[ Dali::Accessibility::State::HIGHLIGHTABLE ] );
+
+  control.SetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, false );
+  DALI_TEST_EQUALS( Property::BOOLEAN, control.GetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE ).GetType(), TEST_LOCATION );
+  DALI_TEST_EQUALS( false, control.GetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE ).Get< bool >(), TEST_LOCATION );
+
+  states_by_bridge = Dali::Accessibility::States { TestGetStates( q->GetAddress() )};
+  DALI_TEST_CHECK( !states_by_bridge[ Dali::Accessibility::State::HIGHLIGHTABLE ] );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlAccessibilityHighlightBridgeUp(void)
+{
+  ToolkitTestApplication application;
+
+  auto controla = Control::New();
+  auto controlb = Control::New();
+  controla.Add(controlb);
+
+  controla.SetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true );
+  controlb.SetProperty( DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto accessible_a = Dali::Accessibility::Accessible::Get( controla );
+  auto accessible_b = Dali::Accessibility::Accessible::Get( controlb );
+
+  auto a = dynamic_cast<Dali::Accessibility::Component*>( accessible_a );
+  auto b = dynamic_cast<Dali::Accessibility::Component*>( accessible_b );
+
+  auto states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  auto states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( !states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+  DALI_TEST_EQUALS( true, DevelControl::GrabAccessibilityHighlight(controla), TEST_LOCATION );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( !states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+  DALI_TEST_EQUALS( true, DevelControl::GrabAccessibilityHighlight(controlb), TEST_LOCATION );
+  DALI_TEST_EQUALS( true, DevelControl::GrabAccessibilityHighlight(controlb), TEST_LOCATION );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+  DALI_TEST_EQUALS( false, DevelControl::ClearAccessibilityHighlight(controla), TEST_LOCATION );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+  DALI_TEST_EQUALS( true, DevelControl::ClearAccessibilityHighlight(controlb), TEST_LOCATION );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( !states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+  DALI_TEST_CHECK( TestGrabHighlight( a -> GetAddress() ) );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( !states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+  DALI_TEST_CHECK( TestGrabHighlight( b -> GetAddress() ) );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+  DALI_TEST_CHECK( TestClearHighlight( b -> GetAddress() ) );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a->GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b->GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::HIGHLIGHTED ] );
+  DALI_TEST_CHECK( !states_by_bridge_b[ Dali::Accessibility::State::HIGHLIGHTED ] );
+
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityControlAttributes(void)
+{
+  ToolkitTestApplication application;
+  auto check_box_button = Toolkit::Control::New();
+
+  std::string value;
+
+
+  auto attributes = check_box_button.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+  auto attributes_map = attributes.GetMap();
+
+  auto position = attributes_map->Find( "access_key1" );
+  DALI_TEST_CHECK( !position );
+
+  DevelControl::AppendAccessibilityAttribute( check_box_button, "access_key1", "access_value1" );
+  attributes = check_box_button.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+  attributes_map = attributes.GetMap();
+
+  DALI_TEST_EQUALS( (attributes_map->Find( "access_key1" ))->Get<std::string>(), "access_value1", TEST_LOCATION );
+
+  DevelControl::AppendAccessibilityAttribute( check_box_button, "access_key2", "access_value2_a" );
+  attributes = check_box_button.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+  attributes_map = attributes.GetMap();
+
+  DALI_TEST_EQUALS( (attributes_map->Find( "access_key1" ))->Get<std::string>(), "access_value1", TEST_LOCATION );
+  DALI_TEST_EQUALS( (attributes_map->Find( "access_key2" ))->Get<std::string>(), "access_value2_a", TEST_LOCATION );
+
+  DevelControl::AppendAccessibilityAttribute( check_box_button, "access_key2", "access_value2_b" );
+  attributes = check_box_button.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+  attributes_map = attributes.GetMap();
+
+  DALI_TEST_EQUALS( (attributes_map->Find( "access_key2" ))->Get<std::string>(), "access_value2_b", TEST_LOCATION );
+
+  DevelControl::RemoveAccessibilityAttribute( check_box_button, "access_key2" );
+  attributes = check_box_button.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+  attributes_map = attributes.GetMap();
+
+  // In case when we are removing one of attributes the property is setting for NONE type.
+  DALI_TEST_EQUALS( (attributes_map->Find( "access_key2" ))->GetType(), Property::NONE, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto ptr = Dali::Accessibility::Accessible::Get( check_box_button );
+  auto attribute_map_bridge = TestGetAttributes( ptr->GetAddress() );
+  auto counter = 0u;
+  for (auto i = 0u; i<attributes_map->Count();++i)
+    if((attributes_map->GetValue(i)).GetType() != Property::NONE )
+      ++counter;
+
+  DALI_TEST_EQUALS( counter, attribute_map_bridge.size(), TEST_LOCATION );
+
+  for (auto it : attribute_map_bridge)
+    DALI_TEST_EQUALS( (attributes_map->Find( it.first ))->Get<std::string>(), it.second, TEST_LOCATION );
+
+  DevelControl::ClearAccessibilityAttributes(check_box_button);
+  attributes = check_box_button.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+  attributes_map = attributes.GetMap();
+
+  position = attributes_map->Find( "access_key1" );
+  DALI_TEST_CHECK( !position );
+
+  position = attributes_map->Find( "access_key2" );
+  DALI_TEST_CHECK( !position );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliControlReadingInfoType(void)
+{
+  ToolkitTestApplication application;
+  auto control = Control::New();
+
+  auto reading_info_type = DevelControl::GetAccessibilityReadingInfoType(control);
+  reading_info_type[Dali::Accessibility::ReadingInfoType::DESCRIPTION] = true;
+  reading_info_type[Dali::Accessibility::ReadingInfoType::STATE] = true;
+  reading_info_type[Dali::Accessibility::ReadingInfoType::NAME] = true;
+  reading_info_type[Dali::Accessibility::ReadingInfoType::ROLE] = true;
+
+  DevelControl::SetAccessibilityReadingInfoType(control, reading_info_type);
+
+  auto q = control.GetProperty( Toolkit::DevelControl::Property::ACCESSIBILITY_ATTRIBUTES );
+  auto z = q.GetMap();
+
+  DALI_TEST_EQUALS( (z->Find( "reading_info_type" ))->Get<std::string>(), "name|role|description|state", TEST_LOCATION );
+  reading_info_type = DevelControl::GetAccessibilityReadingInfoType(control);
+  for ( auto i = 0u; i < 4; ++i)
+    DALI_TEST_CHECK ( reading_info_type[ static_cast< Dali::Accessibility::ReadingInfoType >( i ) ]);
+
+  END_TEST;
+}
+
+int UtcDaliControlDoGesture(void)
+{
+  ToolkitTestApplication application;
+  auto control = Control::New();
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( control );
+  auto gesture_one = Dali::Accessibility::GestureInfo { Dali::Accessibility::Gesture::ONE_FINGER_FLICK_LEFT, 600, 100, 500, 500, Dali::Accessibility::GestureState::BEGIN, 1000 };
+  auto gesture_two = Dali::Accessibility::GestureInfo { Dali::Accessibility::Gesture::ONE_FINGER_FLICK_RIGHT, 600, 100, 500, 500, Dali::Accessibility::GestureState::BEGIN, 1000 };
+
+  DALI_TEST_CHECK( !accessible->DoGesture( gesture_one ) );
+  DALI_TEST_CHECK( !TestDoGesture( accessible->GetAddress(), Dali::Accessibility::Gesture::ONE_FINGER_FLICK_LEFT, 600, 100, 500, 500, Dali::Accessibility::GestureState::BEGIN, 1000 ) );
+
+  DevelControl::AccessibilityDoGestureSignal(control).Connect( [] ( std::pair< Dali::Accessibility::GestureInfo, bool > &gesture ) {
+  if ( gesture.first.type == Dali::Accessibility::Gesture::ONE_FINGER_FLICK_LEFT )
+    gesture.second = true;
+  else
+    gesture.second = false;
+  } );
+
+  DALI_TEST_CHECK( accessible->DoGesture( gesture_one ) );
+  DALI_TEST_CHECK( TestDoGesture( accessible->GetAddress(), Dali::Accessibility::Gesture::ONE_FINGER_FLICK_LEFT, 600, 100, 500, 500, Dali::Accessibility::GestureState::BEGIN, 1000 ) );
+
+  DALI_TEST_CHECK( !accessible->DoGesture( gesture_two ) );
+  DALI_TEST_CHECK( !TestDoGesture( accessible->GetAddress(), Dali::Accessibility::Gesture::ONE_FINGER_FLICK_RIGHT, 600, 100, 500, 500, Dali::Accessibility::GestureState::BEGIN, 1000 ) );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityRelation(void)
+{
+  ToolkitTestApplication application;
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto rel = Accessibility::RelationType::FLOWS_TO;
+  auto number = static_cast< size_t >( rel );
+  auto control = Control::New();
+  auto destination1 = Control::New();
+  auto destination2 = Control::New();
+
+  DevelControl::AppendAccessibilityRelation( control, destination1, rel );
+  auto relations = DevelControl::GetAccessibilityRelations(control);
+  DALI_TEST_CHECK( relations[ number ].size() == 1 );
+
+  DevelControl::AppendAccessibilityRelation( control, destination2, rel );
+  relations = DevelControl::GetAccessibilityRelations(control);
+  DALI_TEST_CHECK( relations[ number ].size() == 2 );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( control );
+  auto accessible_destination1 = Dali::Accessibility::Accessible::Get( destination1 );
+  auto accessible_destination2 = Dali::Accessibility::Accessible::Get( destination2 );
+  auto relationset = accessible->GetRelationSet();
+
+  DALI_TEST_CHECK( relationset[0].relationType == rel );
+  DALI_TEST_CHECK( relationset[0].targets[0] == accessible_destination1->GetAddress() || relationset[0].targets[1] == accessible_destination1->GetAddress() );
+  DALI_TEST_CHECK( relationset[0].targets[0] == accessible_destination2->GetAddress() || relationset[0].targets[1] == accessible_destination2->GetAddress() );
+
+  auto relationset_bridge = TestGetRelationSet( accessible -> GetAddress() );
+  DALI_TEST_CHECK( static_cast< uint32_t >( relationset[0].relationType ) == std::get<0>( relationset_bridge[0] ) );
+
+  DALI_TEST_CHECK( relationset[0].targets[0] == std::get<1>( relationset_bridge[0] )[0] || relationset[0].targets[1] == std::get<1>( relationset_bridge[0] )[0] );
+  DALI_TEST_CHECK( relationset[0].targets[0] == std::get<1>( relationset_bridge[0] )[1] || relationset[0].targets[1] == std::get<1>( relationset_bridge[0] )[1] );
+
+  DevelControl::RemoveAccessibilityRelation(control,destination2,rel);
+  relations = DevelControl::GetAccessibilityRelations(control);
+  DALI_TEST_CHECK( relations[ number ].size() == 1 );
+
+  DevelControl::ClearAccessibilityRelations(control);
+  relations = DevelControl::GetAccessibilityRelations(control);
+  DALI_TEST_CHECK( relations[ number ].size() == 0 );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityParentChildren(void)
+{
+  ToolkitTestApplication application;
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto parent = Control::New();
+  auto child_1 = Control::New();
+  auto child_2 = Control::New();
+
+  auto parent_accessible = Dali::Accessibility::Accessible::Get( parent );
+  auto child_1_accessible = Dali::Accessibility::Accessible::Get( child_1 );
+  auto child_2_accessible = Dali::Accessibility::Accessible::Get( child_2 );
+
+  auto children = TestGetChildren( parent_accessible -> GetAddress() );
+  DALI_TEST_EQUALS( children.size(), 0, TEST_LOCATION );
+
+  try
+  {
+    TestGetIndexInParent( child_1_accessible -> GetAddress() );
+    DALI_ABORT("Object has parent, test abort");
+  }
+  catch(TestDBusWrapper::error &){}
+
+  try
+  {
+    TestGetChildAtIndex( parent_accessible -> GetAddress(), -1 );
+    DALI_ABORT("Positive index, test abort");
+  }
+  catch(TestDBusWrapper::error &){}
+
+  DALI_TEST_EQUALS( parent_accessible -> GetChildCount(), 0, TEST_LOCATION );
+
+  try
+  {
+    child_1_accessible -> GetIndexInParent();
+    DALI_ABORT("Object has parent, test abort");
+  }
+  catch (Dali::DaliException &){}
+
+  parent.Add(child_1);
+  parent.Add(child_2);
+
+  children = TestGetChildren( parent_accessible -> GetAddress() );
+  DALI_TEST_EQUALS( children.size(), 2, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( parent_accessible -> GetAddress(), TestGetParent( child_1_accessible -> GetAddress() ), TEST_LOCATION );
+  DALI_TEST_EQUALS( child_2_accessible -> GetAddress(), TestGetChildAtIndex( parent_accessible -> GetAddress(), TestGetIndexInParent( child_2_accessible -> GetAddress() ) ), TEST_LOCATION );
+
+  DALI_TEST_EQUALS( parent_accessible,  child_1_accessible -> GetParent(), TEST_LOCATION );
+  DALI_TEST_EQUALS( child_2_accessible, parent_accessible -> GetChildAtIndex( child_2_accessible -> GetIndexInParent() ) , TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityGetLayer(void)
+{
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto control = Control::New();
+  auto accessible_obj = Dali::Accessibility::Accessible::Get( control );
+  auto accessible_component = dynamic_cast<Dali::Accessibility::Component*>(accessible_obj);
+  DALI_TEST_CHECK( accessible_component );
+  DALI_TEST_EQUALS( Dali::Accessibility::ComponentLayer::WINDOW, accessible_component -> GetLayer(), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::Accessibility::ComponentLayer::WINDOW, TestGetLayer( accessible_component -> GetAddress() ), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityGrabFocus(void)
+{
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto controla = Control::New();
+  auto controlb = Control::New();
+
+  Stage::GetCurrent().Add( controla );
+  Stage::GetCurrent().Add( controlb );
+
+  controla.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  controlb.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+  auto a = Dali::Accessibility::Accessible::Get( controla );
+  auto b = Dali::Accessibility::Accessible::Get( controlb );
+
+  auto a_component = dynamic_cast<Dali::Accessibility::Component*>( a );
+  auto b_component = dynamic_cast<Dali::Accessibility::Component*>( b );
+
+  auto states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a_component -> GetAddress() )};
+  auto states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b_component -> GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::FOCUSED ] );
+  DALI_TEST_CHECK( !states_by_bridge_b[ Dali::Accessibility::State::FOCUSED ] );
+
+  DALI_TEST_CHECK( a_component -> GrabFocus() );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a_component -> GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b_component -> GetAddress() )};
+
+  DALI_TEST_CHECK( states_by_bridge_a[ Dali::Accessibility::State::FOCUSED ] );
+  DALI_TEST_CHECK( !states_by_bridge_b[ Dali::Accessibility::State::FOCUSED ] );
+
+  DALI_TEST_CHECK( TestGrabFocus( b_component -> GetAddress() ) );
+
+  states_by_bridge_a = Dali::Accessibility::States { TestGetStates( a_component -> GetAddress() )};
+  states_by_bridge_b = Dali::Accessibility::States { TestGetStates( b_component -> GetAddress() )};
+
+  DALI_TEST_CHECK( !states_by_bridge_a[ Dali::Accessibility::State::FOCUSED ] );
+  DALI_TEST_CHECK( states_by_bridge_b[ Dali::Accessibility::State::FOCUSED ] );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityGetExtents(void)
+{
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto control = Control::New();
+  Stage::GetCurrent().GetRootLayer().Add( control );
+
+  control.SetProperty(Actor::Property::POSITION, Vector3(10, 10, 100));
+  control.SetProperty(Actor::Property::SIZE, Vector2(10, 10));
+
+  application.SendNotification();
+  application.Render( 1 );
+
+  auto a = Dali::Accessibility::Accessible::Get( control );
+  auto a_component = dynamic_cast<Dali::Accessibility::Component*>( a );
+
+  auto extents = a_component->GetExtents(Dali::Accessibility::CoordType::SCREEN);
+  DALI_TEST_EQUALS( extents.x, 5.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( extents.y, 5.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( extents.height, 10.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( extents.width, 10.0f, TEST_LOCATION );
+
+  auto bridge_extents = TestGetExtents( a_component -> GetAddress() );
+  DALI_TEST_EQUALS( std::get< 0 >( bridge_extents ), 5, TEST_LOCATION );
+  DALI_TEST_EQUALS( std::get< 1 >( bridge_extents ), 5, TEST_LOCATION );
+  DALI_TEST_EQUALS( std::get< 2 >( bridge_extents ), 10, TEST_LOCATION );
+  DALI_TEST_EQUALS( std::get< 3 >( bridge_extents ), 10, TEST_LOCATION );
+
+  control.SetProperty( Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+  application.SendNotification();
+  application.Render( 1 );
+
+  extents = a_component->GetExtents(Dali::Accessibility::CoordType::SCREEN);
+  DALI_TEST_EQUALS( extents.x, 10.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( extents.y, 10.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( extents.height, 10.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( extents.width, 10.0f, TEST_LOCATION );
+
+  bridge_extents = TestGetExtents( a_component -> GetAddress() );
+  DALI_TEST_EQUALS( std::get< 0 >( bridge_extents ), 10, TEST_LOCATION );
+  DALI_TEST_EQUALS( std::get< 1 >( bridge_extents ), 10, TEST_LOCATION );
+  DALI_TEST_EQUALS( std::get< 2 >( bridge_extents ), 10, TEST_LOCATION );
+  DALI_TEST_EQUALS( std::get< 3 >( bridge_extents ), 10, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityGetAlpha(void)
+{
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto control = Control::New();
+  auto a = Dali::Accessibility::Accessible::Get( control );
+  auto a_component = dynamic_cast<Dali::Accessibility::Component*>( a );
+
+  DALI_TEST_EQUALS( 0.0, a_component -> GetAlpha(), TEST_LOCATION );
+  DALI_TEST_EQUALS( 0.0, TestGetAlpha( a_component -> GetAddress() ), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityGetMdiZOrder(void)
+{
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto control = Control::New();
+  auto a = Dali::Accessibility::Accessible::Get( control );
+  auto a_component = dynamic_cast<Dali::Accessibility::Component*>( a );
+
+  DALI_TEST_EQUALS( 0, static_cast< int >( a_component -> GetMdiZOrder() ), TEST_LOCATION );
+  DALI_TEST_EQUALS( 0, TestGetMdiZOrder( a_component -> GetAddress() ), TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityAction(void)
+{
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto control = Control::New( );
+  auto a = Dali::Accessibility::Accessible::Get( control );
+  auto b = dynamic_cast<Dali::Accessibility::Action*>( a );
+
+  std::vector< std::string > actions { "activate", "accessibilityActivated", "ReadingSkipped", "ReadingCancelled", "ReadingStopped", "ReadingPaused", "ReadingResumed", "show", "hide" };
+  auto count = b -> GetActionCount();
+
+  DALI_TEST_EQUALS( count, 9, TEST_LOCATION );
+
+  for (auto i = 0u; i<count; ++i)
+  {
+    DALI_TEST_CHECK( Dali::Accessibility::Find( actions, b -> GetActionName( i ) ) );
+    DALI_TEST_EQUALS( b -> GetActionName( i ), b -> GetLocalizedActionName( i ), TEST_LOCATION );
+    DALI_TEST_EQUALS( b -> GetActionDescription( i ), "", TEST_LOCATION );
+    DALI_TEST_EQUALS( b -> GetActionKeyBinding( i ), "", TEST_LOCATION );
+  }
+
+  // Empty strings should be returned for invalid indices
+  DALI_TEST_EQUALS(b->GetActionDescription(count), "", TEST_LOCATION);
+  DALI_TEST_EQUALS(b->GetActionName(count), "", TEST_LOCATION);
+  DALI_TEST_EQUALS(b->GetLocalizedActionName(count), "", TEST_LOCATION);
+  DALI_TEST_EQUALS(b->GetActionKeyBinding(count), "", TEST_LOCATION);
+
+  count = TestGetActionCount(b -> GetAddress());
+
+  DALI_TEST_EQUALS( count, 9, TEST_LOCATION );
+
+  for (auto i = 0u; i<count; ++i)
+  {
+    DALI_TEST_CHECK( Dali::Accessibility::Find( actions, TestGetActionName( b->GetAddress(), i ) ) );
+    DALI_TEST_EQUALS( TestGetActionName( b->GetAddress(), i ), TestGetLocalizedActionName( b->GetAddress(), i ), TEST_LOCATION );
+    DALI_TEST_EQUALS( TestGetActionDescription( b->GetAddress(), i ), "", TEST_LOCATION );
+    DALI_TEST_EQUALS( TestGetActionKeyBinding( b->GetAddress(), i ), "", TEST_LOCATION );
+  }
+
+  DALI_TEST_EQUALS(TestGetActionDescription(b->GetAddress(), count), "", TEST_LOCATION);
+  DALI_TEST_EQUALS(TestGetActionName(b->GetAddress(), count), "", TEST_LOCATION);
+  DALI_TEST_EQUALS(TestGetLocalizedActionName(b->GetAddress(), count), "", TEST_LOCATION);
+  DALI_TEST_EQUALS(TestGetActionKeyBinding(b->GetAddress(), count), "", TEST_LOCATION);
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityDoAction(void)
+{
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC( true );
+  thread_local std::vector< bool > actions_done { false, false, false, false, false, false };
+
+  auto control = Control::New(  );
+  auto a = Dali::Accessibility::Accessible::Get( control );
+  auto b = dynamic_cast<Dali::Accessibility::Action*>( a );
+  std::vector< std::string > actions { "activate", "accessibilityActivated", "ReadingSkipped", "ReadingCancelled", "ReadingStopped", "ReadingPaused", "ReadingResumed", "show", "hide" };
+
+  // Test calling action by name
+  DALI_TEST_CHECK( b -> DoAction( actions[2] ) ); // ReadingSkipped
+  DALI_TEST_CHECK( b -> DoAction( actions[4] ) ); // ReadingStopped
+  DALI_TEST_CHECK( b -> DoAction( actions[4] ) ); // ReadingStopped
+
+  // Negative test of calling action with not defined name
+  DALI_TEST_CHECK( !b -> DoAction( "undefined" ) );
+
+  DevelControl::AccessibilityReadingSkippedSignal(control).Connect( [] () {
+    actions_done[ 1 ] = true;
+  } );
+  DevelControl::AccessibilityReadingCancelledSignal(control).Connect( [] () {
+    actions_done[ 2 ] = true;
+  } );
+  DevelControl::AccessibilityReadingStoppedSignal(control).Connect( [] () {
+    actions_done[ 3 ] = true;
+  } );
+   DevelControl::AccessibilityReadingPausedSignal(control).Connect( [] () {
+    actions_done[ 4 ] = true;
+  } );
+   DevelControl::AccessibilityReadingResumedSignal(control).Connect( [] () {
+    actions_done[ 5 ] = true;
+  } );
+  DevelControl::AccessibilityActivateSignal(control).Connect( [] () {
+    actions_done[ 0 ] = true;
+  } );
+
+  // Test calling action by index
+  DALI_TEST_CHECK( b -> DoAction( 1 ) );
+  DALI_TEST_CHECK( b -> DoAction( 2 ) );
+  DALI_TEST_CHECK( b -> DoAction( 3 ) );
+  DALI_TEST_CHECK( b -> DoAction( 4 ) );
+  DALI_TEST_CHECK( b -> DoAction( 5 ) );
+  DALI_TEST_CHECK( b -> DoAction( 6 ) );
+
+  for ( auto i = 0u; i < actions_done.size(); ++i )
+    {
+      DALI_TEST_CHECK( actions_done[ i ] );
+      actions_done[ i ] = false;
+    }
+
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), 1 ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), 2 ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), 3 ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), 4 ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), 5 ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), 6 ) );
+
+  for ( auto i = 0u; i < actions_done.size(); ++i )
+    {
+      DALI_TEST_CHECK( actions_done[ i ] );
+      actions_done[ i ] = false;
+    }
+
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), actions[ 1 ] ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), actions[ 2 ] ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), actions[ 3 ] ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), actions[ 4 ] ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), actions[ 5 ] ) );
+  DALI_TEST_CHECK( TestDoAction( b -> GetAddress(), actions[ 6 ] ) );
+
+  for ( auto i = 0u; i < actions_done.size(); ++i )
+      DALI_TEST_CHECK( actions_done[ i ] );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+void TestVoidCallback()
+{
+}
+
+int UtcDaliAccessibilitySignals(void)
+{
+  ToolkitTestApplication application;
+  ConnectionTracker connectionTracker;
+  Control control = Control::New();
+
+  DALI_TEST_CHECK( DevelControl::AccessibilityGetNameSignal(control).Empty() );
+  control.ConnectSignal( &connectionTracker, "getName", &TestVoidCallback );
+  DALI_TEST_CHECK( !DevelControl::AccessibilityGetNameSignal(control).Empty() );
+
+  DALI_TEST_CHECK( DevelControl::AccessibilityGetDescriptionSignal(control).Empty() );
+  control.ConnectSignal( &connectionTracker, "getDescription", &TestVoidCallback );
+  DALI_TEST_CHECK( !DevelControl::AccessibilityGetDescriptionSignal(control).Empty() );
+
+  DALI_TEST_CHECK( DevelControl::AccessibilityDoGestureSignal(control).Empty() );
+  control.ConnectSignal( &connectionTracker, "doGesture", &TestVoidCallback );
+  DALI_TEST_CHECK( !DevelControl::AccessibilityDoGestureSignal(control).Empty() );
+
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Controls.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Controls.cpp
new file mode 100644 (file)
index 0000000..bd8f3a4
--- /dev/null
@@ -0,0 +1,677 @@
+#include <dali-toolkit-test-suite-utils.h>
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/controls/table-view/table-view.h>
+#include <dali/devel-api/adaptor-framework/accessibility-impl.h>
+
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
+using namespace Dali::Toolkit;
+
+void utc_dali_accessibility_controls_startup(void)
+{
+  test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
+}
+
+void utc_dali_accessibility_controls_cleanup(void)
+{
+  test_return_value = TET_PASS;
+  //DBusWrapper::Install({}) is a de-install
+  DBusWrapper::Install({});
+}
+
+int UtcDaliControlPropertyAccessibilityTranslationDomain(void)
+{
+  ToolkitTestApplication application;
+
+  auto control = Control::New();
+
+  auto accessibility_translation_domain = DevelControl::Property::ACCESSIBILITY_TRANSLATION_DOMAIN;
+  DALI_TEST_EQUALS( Property::NONE , control.GetProperty( accessibility_translation_domain ).GetType(), TEST_LOCATION );
+
+  control.SetProperty( accessibility_translation_domain, "translation_domain_test_1" );
+  DALI_TEST_EQUALS( "translation_domain_test_1" , control.GetProperty( accessibility_translation_domain ).Get<  std::string  >(), TEST_LOCATION );
+
+  control.SetProperty( accessibility_translation_domain, "translation_domain_test_2" );
+  DALI_TEST_EQUALS( "translation_domain_test_2" , control.GetProperty( accessibility_translation_domain ).Get<  std::string  >(), TEST_LOCATION );
+
+  END_TEST;
+}
+
+// This test shows that when the accessibility bridge is
+// not up, there is no possibility to grab or clear highlight
+int UtcDaliControlAccessibilityHighlight(void)
+{
+  ToolkitTestApplication application;
+  auto controla = Control::New();
+  auto controlb = Control::New();
+
+  DALI_TEST_EQUALS( false, DevelControl::GrabAccessibilityHighlight(controla), TEST_LOCATION );
+  DALI_TEST_EQUALS( false, DevelControl::GrabAccessibilityHighlight(controlb), TEST_LOCATION );
+  DALI_TEST_EQUALS( false, DevelControl::ClearAccessibilityHighlight(controla), TEST_LOCATION );
+  DALI_TEST_EQUALS( false, DevelControl::ClearAccessibilityHighlight(controlb), TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/devel-api/controls/tool-bar/tool-bar.h>
+int UtcDaliAccessibilityToolBarConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto toolbar = ToolBar::New();
+  DALI_TEST_CHECK( toolbar );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( toolbar );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::TOOL_BAR, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityPushButtonConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto pushbutton = PushButton::New();
+  DALI_TEST_CHECK( pushbutton );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( pushbutton );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::PUSH_BUTTON, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityPushButtonStates(void)
+{
+  ToolkitTestApplication application;
+
+  auto pushbutton = PushButton::New();
+  DALI_TEST_CHECK( pushbutton );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( pushbutton );
+  DALI_TEST_CHECK( accessible );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto states = accessible->GetStates();
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::PRESSED ] ), false, TEST_LOCATION );
+
+  // auto button = dynamic_cast<Dali::Toolkit::Button* >( accessible ) ;
+  pushbutton.SetProperty( Toolkit::Button::Property::TOGGLABLE, true );
+  pushbutton.SetProperty( Toolkit::Button::Property::SELECTED, true );
+
+  states = accessible->GetStates();
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::PRESSED ] ), true, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
+int UtcDaliAccessibilityToggleButtonConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto togglebutton = ToggleButton::New();
+  DALI_TEST_CHECK( togglebutton );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( togglebutton );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::TOGGLE_BUTTON, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup.h>
+int UtcDaliAccessibilityTextSelectionPopupConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto textselectionpopup = TextSelectionPopup::New( NULL );
+  DALI_TEST_CHECK( textselectionpopup );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( textselectionpopup );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::DIALOG, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityAlignmentConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto alignment = Alignment::New();
+  DALI_TEST_CHECK( alignment );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( alignment );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityRadioButtonStates(void)
+{
+  ToolkitTestApplication application;
+
+  auto radiobutton = RadioButton::New();
+  DALI_TEST_CHECK( radiobutton );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( radiobutton );
+  DALI_TEST_CHECK( accessible );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto states = accessible->GetStates();
+  DALI_TEST_CHECK( states );
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::CHECKED ] ), false, TEST_LOCATION );
+  radiobutton.SetProperty( Toolkit::RadioButton::Property::SELECTED, true );
+  states = accessible->GetStates();
+  DALI_TEST_CHECK( states );
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::CHECKED ] ), true, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityFlexContainerConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto flexcontainer = FlexContainer::New();
+  DALI_TEST_CHECK( flexcontainer );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( flexcontainer );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityCheckBoxButton(void)
+{
+  ToolkitTestApplication application;
+
+  auto checkboxbutton = CheckBoxButton::New();
+  DALI_TEST_CHECK( checkboxbutton );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( checkboxbutton );
+  DALI_TEST_CHECK( accessible );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  auto states = accessible->GetStates();
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::CHECKED ] ), false, TEST_LOCATION );
+  checkboxbutton.SetProperty( Toolkit::CheckBoxButton::Property::SELECTED, true );
+  states = accessible->GetStates();
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::CHECKED ] ), true, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/devel-api/controls/text-controls/text-selection-toolbar.h>
+int UtcDaliAccessibilityTextSelectionConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto textselectiontoolbar = TextSelectionToolbar::New();
+  DALI_TEST_CHECK( textselectiontoolbar );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( textselectiontoolbar );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::TOOL_BAR, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/accessibility-manager/accessibility-manager-impl.h>
+int UtcDaliAccessibilityManager(void)
+{
+  using attr = Toolkit::AccessibilityManager::AccessibilityAttribute;
+
+  ToolkitTestApplication application;
+
+  Dali::Accessibility::TestEnableSC(true);
+
+  auto accessmanager = new Dali::Toolkit::Internal::AccessibilityManager;
+  auto actor = Control::New();
+
+  const std::string name = "Name";
+  const std::string descr = "Description";
+
+  accessmanager->SetAccessibilityAttribute(actor, attr::ACCESSIBILITY_LABEL, name);
+  DALI_TEST_EQUALS( accessmanager->GetAccessibilityAttribute(actor, attr::ACCESSIBILITY_LABEL), name, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<std::string>(DevelControl::Property::ACCESSIBILITY_NAME), name, TEST_LOCATION );
+
+  accessmanager->SetAccessibilityAttribute(actor, attr::ACCESSIBILITY_TRAIT, "Whatever");
+  DALI_TEST_EQUALS( accessmanager->GetAccessibilityAttribute(actor, attr::ACCESSIBILITY_TRAIT), "", TEST_LOCATION );
+
+  accessmanager->SetAccessibilityAttribute(actor, attr::ACCESSIBILITY_VALUE, "Whatever");
+  DALI_TEST_EQUALS( accessmanager->GetAccessibilityAttribute(actor, attr::ACCESSIBILITY_VALUE), "", TEST_LOCATION );
+
+  accessmanager->SetAccessibilityAttribute(actor, attr::ACCESSIBILITY_HINT, descr);
+  DALI_TEST_EQUALS( accessmanager->GetAccessibilityAttribute(actor, attr::ACCESSIBILITY_HINT), descr, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<std::string>(DevelControl::Property::ACCESSIBILITY_DESCRIPTION), descr, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( accessmanager->GetFocusOrder(actor), 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( accessmanager->GenerateNewFocusOrder(), 1, TEST_LOCATION );
+
+  accessmanager->SetFocusOrder({}, 0);
+  accessmanager->SetFocusOrder(Control::New(), 1);
+  accessmanager->SetFocusOrder(actor, 2);
+  accessmanager->SetFocusOrder(Control::New(), 3);
+
+  DALI_TEST_EQUALS( accessmanager->GetFocusOrder(actor), 2, TEST_LOCATION );
+  DALI_TEST_EQUALS( accessmanager->GetActorByFocusOrder(2), actor, TEST_LOCATION );
+
+  accessmanager->SetCurrentFocusActor(actor);
+  DALI_TEST_EQUALS( accessmanager->GetCurrentFocusActor(), actor, TEST_LOCATION );
+  DALI_TEST_EQUALS( accessmanager->GetCurrentFocusOrder(), 2, TEST_LOCATION );
+
+  accessmanager->MoveFocusForward();
+  accessmanager->MoveFocusBackward();
+  DALI_TEST_EQUALS( accessmanager->GetCurrentFocusActor(), actor, TEST_LOCATION );
+  accessmanager->SetCurrentFocusActor({});
+
+  accessmanager->Reset();
+  accessmanager->MoveFocusBackward();
+  accessmanager->MoveFocusForward();
+
+  accessmanager->GetCurrentFocusGroup();
+  DALI_TEST_EQUALS( accessmanager->IsFocusGroup(actor), false, TEST_LOCATION );
+  accessmanager->GetFocusGroup(actor);
+
+  DALI_TEST_EQUALS( accessmanager->GetGroupMode(), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( accessmanager->GetWrapMode(), true, TEST_LOCATION );
+
+  auto vector = accessmanager->GetReadPosition();
+  DALI_TEST_EQUALS( vector.x, 0.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.y, 0.0f, TEST_LOCATION );
+
+  accessmanager->SetFocusIndicatorActor(Dali::Actor{});
+  accessmanager->GetFocusIndicatorActor();
+
+  Dali::Accessibility::TestEnableSC(false);
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityModel3dViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto model3dview = Model3dView::New();
+  DALI_TEST_CHECK( model3dview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( model3dview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::IMAGE, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/controls/effects-view/effects-view-impl.h>
+int UtcDaliAccessibilityEffectsViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto etype = Dali::Toolkit::EffectsView::EffectType::DROP_SHADOW;
+  auto effectsview = EffectsView::New( etype );
+  DALI_TEST_CHECK( effectsview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( effectsview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/controls/super-blur-view/super-blur-view-impl.h>
+int UtcDaliAccessibilitySuperBlurViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto superblurview = SuperBlurView::New( 1 );
+  DALI_TEST_CHECK( superblurview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( superblurview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityImageViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto imageview = ImageView::New();
+  DALI_TEST_CHECK( imageview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( imageview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::IMAGE, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
+class TestPageFactory : public PageFactory
+{
+public:
+
+  TestPageFactory( bool returnValidTexture = true )
+  : mValidTexture( returnValidTexture )
+  {
+    mTotalPageNumber = 100;
+  }
+
+  /**
+   * Query the number of pages available from the factory.
+   * The maximum available page has an ID of GetNumberOfPages()-1.
+   */
+  virtual unsigned int GetNumberOfPages()
+  {
+    return mTotalPageNumber;
+  }
+
+  /**
+   * Create an texture to represent a page content.
+   * @param[in] pageId The ID of the page to create.
+   * @return An image, or an empty handle if the ID is out of range.
+   */
+  virtual Texture NewPage( unsigned int pageId )
+  {
+    if( mValidTexture )
+    {
+      return Texture::New( Dali::TextureType::TEXTURE_2D, Pixel::RGB888, 100, 100 );
+    }
+    return Texture(); // empty handle
+  }
+
+private:
+  unsigned int            mTotalPageNumber;
+  bool                    mValidTexture;
+};
+
+#include <dali-toolkit/internal/controls/page-turn-view/page-turn-landscape-view-impl.h>
+int UtcDaliAccessibilityPageTurnViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto testpagefactory = TestPageFactory();
+  auto vector2 = Vector2( 1.0, 1.0 );
+  auto pageturnlandscapeview = PageTurnLandscapeView::New( testpagefactory, vector2 );
+  DALI_TEST_CHECK( pageturnlandscapeview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( pageturnlandscapeview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::PAGE_TAB_LIST, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityGaussianBlurViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto gaussianblurview = GaussianBlurView::New();
+  DALI_TEST_CHECK( gaussianblurview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( gaussianblurview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityShadowViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto shadowview = ShadowView::New();
+  DALI_TEST_CHECK( shadowview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( shadowview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
+int UtcDaliAccessibilityScrollableConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto scrollview = ScrollView::New();
+  DALI_TEST_CHECK( scrollview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( scrollview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::SCROLL_PANE, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/controls/magnifier/magnifier-impl.h>
+int UtcDaliAccessibilityMagnifierConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto magnifier = Magnifier::New();
+  DALI_TEST_CHECK( magnifier );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( magnifier );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityTableViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto tableview = TableView::New( 10, 10 );
+  DALI_TEST_CHECK( tableview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( tableview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::TABLE, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/controls/bloom-view/bloom-view-impl.h>
+int UtcDaliAccessibilityBloomViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto bloomview = BloomView::New();
+  DALI_TEST_CHECK( bloomview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( bloomview );
+  DALI_TEST_CHECK( accessible );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::ANIMATION, TEST_LOCATION );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/controls/text-controls/text-field-impl.h>
+int UtcDaliAccessibilityTextField(void)
+{
+  ToolkitTestApplication application;
+
+  auto textfield = TextField::New();
+  DALI_TEST_CHECK( textfield );
+
+  textfield.SetProperty(Actor::Property::NAME, "test" );
+  DALI_TEST_EQUALS( textfield.GetProperty<std::string>(Actor::Property::NAME), "test", TEST_LOCATION );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( textfield );
+  DALI_TEST_CHECK( accessible );
+
+  DALI_TEST_EQUALS( accessible->GetName(), "", TEST_LOCATION );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::ENTRY, TEST_LOCATION );
+  auto states = accessible->GetStates();
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::EDITABLE ] ), true, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  textfield.SetProperty( Toolkit::TextField::Property::TEXT, "test" );
+  auto text = dynamic_cast< Dali::Accessibility::Text* >( accessible );
+  DALI_TEST_CHECK( text );
+  DALI_TEST_EQUALS( text->GetText( 0, 10 ), "", TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetCaretOffset(100), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetCaretOffset(2), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->GetCaretOffset(), 2, TEST_LOCATION );
+
+  auto editabletext = dynamic_cast< Dali::Accessibility::EditableText* >( accessible );
+  DALI_TEST_CHECK( editabletext );
+  DALI_TEST_EQUALS( editabletext->CopyText( 3, 1 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( editabletext->CopyText( 1, 3 ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( editabletext->CutText( 3, 1 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( editabletext->CutText( 1, 3 ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->GetText( 0, 1 ), "t", TEST_LOCATION );
+
+  auto range = text->GetSelection( 1 );
+  DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetSelection( 1, 0, 1 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->RemoveSelection( 1 ), false, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/controls/text-controls/text-editor-impl.h>
+int UtcDaliAccessibilityTextEditor(void)
+{
+  ToolkitTestApplication application;
+
+  auto texteditor = TextEditor::New();
+  DALI_TEST_CHECK( texteditor );
+
+  texteditor.SetProperty(Actor::Property::NAME, "test" );
+  DALI_TEST_EQUALS( texteditor.GetProperty<std::string>(Actor::Property::NAME), "test", TEST_LOCATION );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( texteditor );
+  DALI_TEST_CHECK( accessible );
+
+  DALI_TEST_EQUALS( accessible->GetName(), "", TEST_LOCATION );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::ENTRY, TEST_LOCATION );
+  auto states = accessible->GetStates();
+  DALI_TEST_EQUALS( static_cast< unsigned int >( states[ Accessibility::State::EDITABLE ] ), true, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  texteditor.SetProperty( Toolkit::TextEditor::Property::TEXT, "test" );
+  auto text = dynamic_cast< Dali::Accessibility::Text* >( accessible );
+  DALI_TEST_CHECK( text );
+  DALI_TEST_EQUALS( text->GetText( 0, 10 ), "", TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetCaretOffset(100), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetCaretOffset(2), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->GetCaretOffset(), 2, TEST_LOCATION );
+
+  auto editabletext = dynamic_cast< Dali::Accessibility::EditableText* >( accessible );
+  DALI_TEST_CHECK( editabletext );
+  DALI_TEST_EQUALS( editabletext->CopyText( 3, 1 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( editabletext->CopyText( 1, 3 ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( editabletext->CutText( 3, 1 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( editabletext->CutText( 1, 3 ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->GetText( 0, 1 ), "t", TEST_LOCATION );
+
+  auto range = text->GetSelection( 1 );
+  DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetSelection( 1, 0, 1 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->RemoveSelection( 1 ), false, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityTextLabel(void)
+{
+  ToolkitTestApplication application;
+
+  auto textlabel = TextLabel::New();
+  DALI_TEST_CHECK( textlabel );
+
+  textlabel.SetProperty(Actor::Property::NAME, "test" );
+  DALI_TEST_EQUALS( textlabel.GetProperty<std::string>(Actor::Property::NAME), "test", TEST_LOCATION );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( textlabel );
+  DALI_TEST_CHECK( accessible );
+
+  DALI_TEST_EQUALS( accessible->GetName(), "test", TEST_LOCATION );
+  DALI_TEST_EQUALS( accessible->GetRole(), Accessibility::Role::LABEL, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( true );
+
+  textlabel.SetProperty( Toolkit::TextLabel::Property::TEXT, "test" );
+  auto text = dynamic_cast< Dali::Accessibility::Text* >( accessible );
+  DALI_TEST_CHECK( text );
+  DALI_TEST_EQUALS( text->GetText( 0, 10 ), "", TEST_LOCATION );
+  DALI_TEST_EQUALS( text->GetText( 0, 4 ), "test", TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetCaretOffset(0), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->GetCaretOffset(), 0, TEST_LOCATION );
+
+  auto range = text->GetSelection( 1 );
+  DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+  DALI_TEST_EQUALS( text->SetSelection( 1, 0, 1 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( text->RemoveSelection( 1 ), false, TEST_LOCATION );
+
+  Dali::Accessibility::TestEnableSC( false );
+
+  END_TEST;
+}
+
+#include <dali-toolkit/internal/controls/navigation-view/navigation-view-impl.h>
+int UtcDaliAccessibilityNavigationViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto navigationview = NavigationView::New();
+  DALI_TEST_CHECK( navigationview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( navigationview );
+  DALI_TEST_CHECK( accessible );
+
+  DALI_TEST_EQUALS( accessible->GetRole(), Dali::Accessibility::Role::FILLER, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityVideoViewConstructor(void)
+{
+  ToolkitTestApplication application;
+
+  auto videoview = VideoView::New();
+  DALI_TEST_CHECK( videoview );
+
+  auto accessible = Dali::Accessibility::Accessible::Get( videoview );
+  DALI_TEST_CHECK( accessible );
+
+  DALI_TEST_EQUALS( accessible->GetRole(), Dali::Accessibility::Role::VIDEO, TEST_LOCATION );
+
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Text.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Text.cpp
new file mode 100644 (file)
index 0000000..7bc4fe1
--- /dev/null
@@ -0,0 +1,486 @@
+/**
+ * Copyright (c) 2017 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.
+ *
+ */
+
+// Need to override adaptor classes for toolkit test harness, so include
+// test harness headers before dali headers.
+#include <dali-toolkit-test-suite-utils.h>
+
+#include <dali.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+#include <dali-toolkit/internal/controls/text-controls/text-editor-impl.h>
+
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
+void utc_dali_toolkit_accessibility_text_startup(void)
+{
+  test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
+}
+
+void utc_dali_toolkit_accessibility_text_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+int utcDaliAccessibilityTextEditorGetName(void)
+{
+  ToolkitTestApplication application;
+
+  auto editor = Dali::Toolkit::TextEditor::New();
+  DALI_TEST_EQUALS( editor.GetProperty<std::string>(Actor::Property::NAME), "", TEST_LOCATION );
+  editor.SetProperty(Actor::Property::NAME, "editor");
+  DALI_TEST_EQUALS( editor.GetProperty<std::string>(Actor::Property::NAME), "editor", TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextEditorGetText(void)
+{
+  ToolkitTestApplication application;
+
+  auto editor = Dali::Toolkit::TextEditor::New();
+  auto q = Dali::Accessibility::Accessible::Get( editor );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    DALI_TEST_EQUALS( x->GetText( 0, 0 ), "", TEST_LOCATION );
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "exemplary_text" );
+    DALI_TEST_EQUALS( x->GetText( 0, 9 ), "exemplary", TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextEditorGetCharacterCount(void)
+{
+  ToolkitTestApplication application;
+
+  auto editor = Dali::Toolkit::TextEditor::New();
+  auto q = Dali::Accessibility::Accessible::Get( editor );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    DALI_TEST_EQUALS( x->GetCharacterCount(), 0, TEST_LOCATION );
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "editor" );
+    DALI_TEST_EQUALS( x->GetCharacterCount(), 6, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextEditorGetTextAtOffset(void)
+{
+  ToolkitTestApplication application;
+
+  auto editor = Dali::Toolkit::TextEditor::New();
+  auto q = Dali::Accessibility::Accessible::Get( editor );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetTextAtOffset( 0, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "text editor test sentence" );
+    range = x->GetTextAtOffset( 5, Dali::Accessibility::TextBoundary::CHARACTER );
+    DALI_TEST_EQUALS( range.content, "e", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 5, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 6, TEST_LOCATION );
+
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "text \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 3, Dali::Accessibility::TextBoundary::WORD );
+    DALI_TEST_EQUALS( range.content, "sentence", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 28, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 36, TEST_LOCATION );
+
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "text \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 4, Dali::Accessibility::TextBoundary::WORD );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 0, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, "text    \n", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 6, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, " editor  \n", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 14, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 24, TEST_LOCATION );
+
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 8, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, " test sentence", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 25, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 39, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextEditorGetSetSelection(void)
+{
+  ToolkitTestApplication application;
+
+  auto editor = Dali::Toolkit::TextEditor::New();
+  auto q = Dali::Accessibility::Accessible::Get( editor );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+
+    x->SetSelection( 0, 4, 9 );
+    editor.SetProperty( Toolkit::TextEditor::Property::TEXT, "exemplary_text" );
+    range = x->GetSelection( 0 );
+
+    DALI_TEST_EQUALS( range.startOffset, 4, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.content, "plary", TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextEditorRemoveSelection(void)
+{
+  ToolkitTestApplication application;
+
+  auto editor = Dali::Toolkit::TextEditor::New();
+  auto q = Dali::Accessibility::Accessible::Get( editor );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    x->SetSelection( 0, 4, 9 );
+    range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 4, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+
+    x->RemoveSelection( 0 );
+    range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextFieldGetName(void)
+{
+  ToolkitTestApplication application;
+
+  auto field = Toolkit::TextField::New();
+  DALI_TEST_EQUALS( field.GetProperty<std::string>(Actor::Property::NAME), "", TEST_LOCATION );
+  field.SetProperty(Actor::Property::NAME, "field");
+  DALI_TEST_EQUALS( field.GetProperty<std::string>(Actor::Property::NAME), "field", TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextFieldGetText(void)
+{
+  ToolkitTestApplication application;
+
+  auto field = Dali::Toolkit::TextField::New();
+  auto q = Dali::Accessibility::Accessible::Get( field );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    DALI_TEST_EQUALS( x->GetText( 0, 0 ), "", TEST_LOCATION );
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "exemplary_text" );
+    DALI_TEST_EQUALS( x->GetText( 0, 9 ), "exemplary", TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextFieldGetCharacterCount(void)
+{
+  ToolkitTestApplication application;
+
+  auto field = Dali::Toolkit::TextField::New();
+  auto q = Dali::Accessibility::Accessible::Get( field );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    DALI_TEST_EQUALS( x->GetCharacterCount(), 0, TEST_LOCATION );
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "field" );
+    DALI_TEST_EQUALS( x->GetCharacterCount(), 5, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextFieldGetTextAtOffset(void)
+{
+  ToolkitTestApplication application;
+
+  auto field = Dali::Toolkit::TextField::New();
+  auto q = Dali::Accessibility::Accessible::Get( field );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetTextAtOffset( 0, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "text editor test sentence" );
+    range = x->GetTextAtOffset( 5, Dali::Accessibility::TextBoundary::CHARACTER );
+    DALI_TEST_EQUALS( range.content, "e", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 5, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 6, TEST_LOCATION );
+
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "text \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 3, Dali::Accessibility::TextBoundary::WORD );
+    DALI_TEST_EQUALS( range.content, "sentence", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 28, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 36, TEST_LOCATION );
+
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "text \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 4, Dali::Accessibility::TextBoundary::WORD );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 0, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, "text    \n", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 6, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, " editor  \n", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 14, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 24, TEST_LOCATION );
+
+    field.SetProperty( Toolkit::TextField::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 8, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, " test sentence", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 25, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 39, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextFieldGetSetSelection(void)
+{
+  ToolkitTestApplication application;
+
+  auto field = Dali::Toolkit::TextField::New();
+  auto q = Dali::Accessibility::Accessible::Get( field );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+
+    x->SetSelection( 0, 4, 9 );
+    field.SetProperty( Toolkit::TextEditor::Property::TEXT, "exemplary_text" );
+    range = x->GetSelection( 0 );
+
+    DALI_TEST_EQUALS( range.startOffset, 4, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.content, "plary", TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextFieldRemoveSelection(void)
+{
+  ToolkitTestApplication application;
+
+  auto field = Dali::Toolkit::TextField::New();
+  auto q = Dali::Accessibility::Accessible::Get( field );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    x->SetSelection( 0, 4, 9 );
+    range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 4, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+
+    x->RemoveSelection( 0 );
+    range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextLabelGetName(void)
+{
+  ToolkitTestApplication application;
+
+  auto label = Toolkit::TextLabel::New();
+  DALI_TEST_EQUALS( label.GetProperty<std::string>(Actor::Property::NAME), "", TEST_LOCATION );
+  label.SetProperty(Actor::Property::NAME, "label");
+  DALI_TEST_EQUALS( label.GetProperty<std::string>(Actor::Property::NAME), "label", TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextLabelGetText(void)
+{
+  ToolkitTestApplication application;
+
+  auto label = Dali::Toolkit::TextLabel::New();
+  auto q = Dali::Accessibility::Accessible::Get( label );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    DALI_TEST_EQUALS( x->GetText( 0, 0 ), "", TEST_LOCATION );
+    label.SetProperty( Toolkit::TextField::Property::TEXT, "exemplary_text" );
+    DALI_TEST_EQUALS( x->GetText( 0, 9 ), "exemplary", TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextLabelGetCharacterCount(void)
+{
+  ToolkitTestApplication application;
+
+  auto label = Dali::Toolkit::TextLabel::New();
+  auto q = Dali::Accessibility::Accessible::Get( label );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    DALI_TEST_EQUALS( x->GetCharacterCount(), 0, TEST_LOCATION );
+    label.SetProperty( Toolkit::TextField::Property::TEXT, "field" );
+    DALI_TEST_EQUALS( x->GetCharacterCount(), 5, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextLabelGetTextAtOffset(void)
+{
+  ToolkitTestApplication application;
+
+  auto label = Dali::Toolkit::TextLabel::New();
+  auto q = Dali::Accessibility::Accessible::Get( label );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetTextAtOffset( 0, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    label.SetProperty( Toolkit::TextLabel::Property::TEXT, "text editor test sentence" );
+    range = x->GetTextAtOffset( 5, Dali::Accessibility::TextBoundary::CHARACTER );
+    DALI_TEST_EQUALS( range.content, "e", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 5, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 6, TEST_LOCATION );
+
+    label.SetProperty( Toolkit::TextLabel::Property::TEXT, "text \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 3, Dali::Accessibility::TextBoundary::WORD );
+    DALI_TEST_EQUALS( range.content, "sentence", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 28, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 36, TEST_LOCATION );
+
+    label.SetProperty( Toolkit::TextLabel::Property::TEXT, "text \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 4, Dali::Accessibility::TextBoundary::WORD );
+    DALI_TEST_EQUALS( range.content, "", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    label.SetProperty( Toolkit::TextLabel::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 0, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, "text    \n", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+
+    label.SetProperty( Toolkit::TextLabel::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 6, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, " editor  \n", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 14, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 24, TEST_LOCATION );
+
+    label.SetProperty( Toolkit::TextLabel::Property::TEXT, "text    \n\n\n\n\n\n editor  \n\n test sentence" );
+    range = x->GetTextAtOffset( 8, Dali::Accessibility::TextBoundary::LINE );
+    DALI_TEST_EQUALS( range.content, " test sentence", TEST_LOCATION );
+    DALI_TEST_EQUALS( range.startOffset, 25, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 39, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityTextLabelRemoveSelection( void )
+{
+  ToolkitTestApplication application;
+
+  auto label = Dali::Toolkit::TextLabel::New();
+  auto q = Dali::Accessibility::Accessible::Get( label );
+  auto x = dynamic_cast< Dali::Accessibility::Text* >( q );
+  DALI_TEST_CHECK( x );
+  if( x )
+  {
+    auto range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+
+    x->SetSelection( 0, 4, 9 );
+    range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 4, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 9, TEST_LOCATION );
+
+    x->RemoveSelection( 0 );
+    range = x->GetSelection( 0 );
+    DALI_TEST_EQUALS( range.startOffset, 0, TEST_LOCATION );
+    DALI_TEST_EQUALS( range.endOffset, 0, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Value.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Accessibility-Value.cpp
new file mode 100644 (file)
index 0000000..af4739b
--- /dev/null
@@ -0,0 +1,268 @@
+/**
+ * Copyright (c) 2017 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.
+ *
+ */
+
+// Need to override adaptor classes for toolkit test harness, so include
+// test harness headers before dali headers.
+#include <dali-toolkit-test-suite-utils.h>
+
+#include <dali.h>
+#include <dali/devel-api/common/stage.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+#include <dali/devel-api/adaptor-framework/accessibility-impl.h>
+
+#include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
+
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
+using namespace Dali::Accessibility;
+
+void utc_dali_toolkit_accessibility_value_startup(void)
+{
+  test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
+}
+
+void utc_dali_toolkit_accessibility_value_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+int utcDaliAccessibilityProgressBarGetMinimum(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::ProgressBar progress_bar = Toolkit::ProgressBar::New();
+  auto q = Dali::Accessibility::Accessible::Get( progress_bar );
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMinimum(), 0.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityProgressBarGetMaximum(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::ProgressBar progress_bar = Toolkit::ProgressBar::New();
+  auto q = Dali::Accessibility::Accessible::Get( progress_bar );
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMaximum(), 1.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityProgressBarGetMinimumIncrement(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::ProgressBar progress_bar = Toolkit::ProgressBar::New();
+  auto q = Dali::Accessibility::Accessible::Get(progress_bar);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMinimumIncrement(), 0.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityProgressBarGetSetCurrent(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::ProgressBar progress_bar = Toolkit::ProgressBar::New();
+  auto q = Dali::Accessibility::Accessible::Get(progress_bar);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetCurrent(), 0.0, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->SetCurrent( 2.0 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->SetCurrent( 0.25 ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->GetCurrent(), 0.25, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityScrollBarGetMinimum(void)
+{
+  ToolkitTestApplication application;
+
+  // Create a source actor that owns the scroll properties required by the scroll bar
+  Actor sourceActor = Actor::New();
+  Stage::GetCurrent().Add( sourceActor );
+
+  // Register the scroll properties
+  Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition",  0.0f );
+  Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin",   10.0f );
+  Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax",   100.0f );
+  Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize",   500.0f );
+
+  Toolkit::ScrollBar scroll_bar = Toolkit::ScrollBar::New();
+
+  scroll_bar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
+
+  auto q = Dali::Accessibility::Accessible::Get(scroll_bar);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMinimum(), 10.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityScrollBarGetMaximum(void)
+{
+  ToolkitTestApplication application;
+
+  // Create a source actor that owns the scroll properties required by the scroll bar
+  Actor sourceActor = Actor::New();
+  Stage::GetCurrent().Add( sourceActor );
+
+  // Register the scroll properties
+  Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition",  0.0f );
+  Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin",   0.0f );
+  Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax",   100.0f );
+  Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize",   500.0f );
+
+  Toolkit::ScrollBar scroll_bar = Toolkit::ScrollBar::New();
+
+  scroll_bar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
+
+  auto q = Dali::Accessibility::Accessible::Get(scroll_bar);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMaximum(), 100.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityScrollBarGetMinimumIncrement(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::ScrollBar scroll_bar = Toolkit::ScrollBar::New();
+  auto q = Dali::Accessibility::Accessible::Get(scroll_bar);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMinimumIncrement(), 1.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilityScrollBarGetSetCurrent(void)
+{
+  ToolkitTestApplication application;
+
+  // Create a source actor that owns the scroll properties required by the scroll bar
+  Actor sourceActor = Actor::New();
+  Stage::GetCurrent().Add( sourceActor );
+
+  // Register the scroll properties
+  Property::Index propertyScrollPosition = sourceActor.RegisterProperty( "sourcePosition",  0.0f );
+  Property::Index propertyMinScrollPosition = sourceActor.RegisterProperty( "sourcePositionMin",   0.0f );
+  Property::Index propertyMaxScrollPosition = sourceActor.RegisterProperty( "sourcePositionMax",   100.0f );
+  Property::Index propertyScrollContentSize = sourceActor.RegisterProperty( "sourceContentSize",   500.0f );
+
+  Toolkit::ScrollBar scroll_bar = Toolkit::ScrollBar::New();
+
+  scroll_bar.SetScrollPropertySource(sourceActor, propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
+
+  //sourceActor.SetProperty(propertyScrollPosition, 20.0f);
+
+  auto q = Dali::Accessibility::Accessible::Get(scroll_bar);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetCurrent(), 0.0, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->SetCurrent( 1000.0 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->SetCurrent( 50.0 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->GetCurrent(), 0.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilitySliderGetMinimum(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::Slider slider = Toolkit::Slider::New();
+  auto q = Dali::Accessibility::Accessible::Get(slider);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMinimum(), 0.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilitySliderGetMaximum(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::Slider slider = Toolkit::Slider::New();
+  auto q = Dali::Accessibility::Accessible::Get(slider);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetMaximum(), 1.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilitySliderGetMinimumIncrement(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::Slider slider = Toolkit::Slider::New();
+  auto q = Dali::Accessibility::Accessible::Get(slider);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS<float>( x->GetMinimumIncrement(), 0.0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliAccessibilitySliderGetSetCurrent(void)
+{
+  ToolkitTestApplication application;
+
+  Toolkit::Slider slider = Toolkit::Slider::New();
+  auto q = Dali::Accessibility::Accessible::Get(slider);
+  auto x = dynamic_cast< Dali::Accessibility::Value* >( q );
+  DALI_TEST_CHECK( x );
+  DALI_TEST_EQUALS( x->GetCurrent(), 0.0, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->SetCurrent( 2.0 ), false, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->SetCurrent( 0.25 ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( x->GetCurrent(), 0.25, TEST_LOCATION );
+
+  const float MIN_BOUND = 0.0f;
+  const float MAX_BOUND = 1.0f;
+  const int NUM_MARKS = 5;
+  Property::Array marks;
+  for( int i = 0; i < NUM_MARKS; ++i )
+  {
+    marks.PushBack( MIN_BOUND + ( static_cast<float>(i) / ( NUM_MARKS - 1) ) * ( MAX_BOUND - MIN_BOUND ) );
+  }
+  slider.SetProperty( Toolkit::Slider::Property::MARKS, marks );
+  // when current value is not a mark, set new value to the closest mark
+  DALI_TEST_CHECK( x->SetCurrent( 0.1f ) );
+  slider.SetProperty( Toolkit::Slider::Property::SNAP_TO_MARKS, true );
+  DALI_TEST_CHECK( x->SetCurrent( 0.7f ) );
+  DALI_TEST_EQUALS( static_cast<float>( x->GetCurrent() ), marks[3].Get<float>(), TEST_LOCATION );
+  // when current value is a mark at index i set new value to the mark at index i +/- 1
+  // depending if the new value is greater/less than current value
+  DALI_TEST_CHECK( x->SetCurrent( 0.2f ) );
+  DALI_TEST_EQUALS( static_cast<float>( x->GetCurrent() ),  marks[2].Get<float>(), TEST_LOCATION );
+  END_TEST;
+}
index 14cef1c..6e41930 100644 (file)
 #include <dali-toolkit-test-suite-utils.h>
 #include <dali-toolkit/internal/helpers/color-conversion.h>
 
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
 using namespace Dali;
 using namespace Dali::Toolkit;
 
 void dali_color_conversion_startup(void)
 {
   test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
 }
 
 void dali_color_conversion_cleanup(void)
index fe01738..12276e8 100755 (executable)
@@ -25,6 +25,9 @@
 #include <dali-toolkit/dali-toolkit.h>
 
 #include <toolkit-environment-variable.h> // for setting environment variable: DALI_DEBUG_RENDERING
+
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
 #include "dummy-control.h"
 
 using namespace Dali;
@@ -75,6 +78,7 @@ void TestDebugVisual( Integration::Scene scene,  Visual::Base& visual, Visual::T
 void dali_debug_rendering_startup(void)
 {
   test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
 }
 
 void dali_debug_rendering_cleanup(void)
index 58fc510..df76c38 100644 (file)
 #include <dali-toolkit-test-suite-utils.h>
 #include <dali-toolkit/internal/helpers/property-helper.h>
 
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
 using namespace Dali;
 using namespace Dali::Toolkit;
 
 void dali_property_helper_startup(void)
 {
   test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
 }
 
 void dali_property_helper_cleanup(void)
index 13c7ca8..06ce4c8 100644 (file)
 #include <dali-toolkit/internal/controls/text-controls/text-selection-popup-impl.h>
 #undef private
 
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
+
 using namespace Dali;
 using namespace Toolkit;
 
 void dali_textselectionpopupinternal_startup(void)
 {
   test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
 }
 
 void dali_textselectionpopupinternal_cleanup(void)
index a6b7460..c1ea9ad 100644 (file)
 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
 
-using namespace Dali::Toolkit::Internal;
+#include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
 
+using namespace Dali::Toolkit::Internal;
 
 void utc_dali_toolkit_texture_manager_startup(void)
 {
   setenv( "LOG_TEXTURE_MANAGER", "3", 1 );
   test_return_value = TET_UNDEF;
+  DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
 }
 
 void utc_dali_toolkit_texture_manager_cleanup(void)
index 4148b92..bda1454 100644 (file)
@@ -14,7 +14,6 @@ SET(TC_SOURCES
 LIST(APPEND TC_SOURCES
    ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-adaptor.cpp
-   ../dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-application.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
    ../dali-toolkit/dali-toolkit-test-utils/toolkit-color-controller.cpp
@@ -55,6 +54,7 @@ LIST(APPEND TC_SOURCES
 
 PKG_CHECK_MODULES(${CAPI_LIB} REQUIRED
   dali2-core
+  dali2-adaptor
   dali2-toolkit
 )
 
index 3719b4d..e089fc6 100644 (file)
@@ -12,6 +12,17 @@ SET(TC_SOURCES
 
 # Append list of test harness files (Won't get parsed for test cases)
 LIST(APPEND TC_SOURCES
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-application.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-event-thread-callback.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-environment-variable.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-input-method-context.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-orientation.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-physical-keyboard.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-style-monitor.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
+   ../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
    ../dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp
    ../dali-toolkit/dali-toolkit-test-utils/mesh-builder.cpp
    ../dali-toolkit/dali-toolkit-test-utils/test-actor-utils.cpp
index d889c6f..f21b289 100755 (executable)
@@ -47,7 +47,6 @@ SET(TC_SOURCES
   utc-Dali-Button.cpp
   utc-Dali-Control.cpp
   utc-Dali-ControlImpl.cpp
-  utc-Dali-AccessibilityManager.cpp
   utc-Dali-ItemLayout.cpp
   utc-Dali-ItemView.cpp
   utc-Dali-KeyboardFocusManager.cpp
@@ -77,7 +76,6 @@ SET(TC_SOURCES
 # Append list of test harness files (Won't get parsed for test cases)
 LIST(APPEND TC_SOURCES
   dali-toolkit-test-utils/toolkit-adaptor.cpp
-  dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
   dali-toolkit-test-utils/toolkit-application.cpp
   dali-toolkit-test-utils/toolkit-clipboard.cpp
   dali-toolkit-test-utils/toolkit-clipboard-event-notifier.cpp
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
deleted file mode 100644 (file)
index 72d4106..0000000
+++ /dev/null
@@ -1,607 +0,0 @@
-/*
- * Copyright (c) 2020 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/public-api/object/base-object.h>
-#include <dali/devel-api/adaptor-framework/accessibility-adaptor.h>
-#include <dali/devel-api/adaptor-framework/accessibility-action-handler.h>
-#include <dali/devel-api/adaptor-framework/accessibility-gesture-handler.h>
-#include <dali/devel-api/adaptor-framework/accessibility-gesture-event.h>
-#include <dali/integration-api/events/touch-integ.h>
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-namespace Adaptor
-{
-
-/**
- * Stub for the AccessibilityAdaptor
- */
-class AccessibilityAdaptor : public BaseObject
-{
-public: // Creation & Destruction
-
-  static Dali::AccessibilityAdaptor Get();
-
-  AccessibilityAdaptor();
-  ~AccessibilityAdaptor();
-
-public:
-
-  // Functions to modify mock returns:
-
-  void MockSetReadPosition( Vector2& position );
-
-  void SetEnabled(bool enabled)
-  {
-    mIsEnabled = enabled;
-  }
-
-  void SendPanGesture( const AccessibilityGestureEvent& panEvent );
-
-public:
-
-  bool IsEnabled() const;
-  void SetActionHandler(Dali::AccessibilityActionHandler& handler);
-  void SetGestureHandler(Dali::AccessibilityGestureHandler& handler);
-
-  Vector2 GetReadPosition() const;
-
-  bool HandleActionNextEvent(bool);
-  bool HandleActionPreviousEvent(bool);
-  bool HandleActionActivateEvent();
-  bool HandleActionReadEvent(unsigned int x, unsigned int y, bool allowReadAgain);
-  bool HandleActionReadNextEvent(bool);
-  bool HandleActionReadPreviousEvent(bool);
-  bool HandleActionUpEvent();
-  bool HandleActionDownEvent();
-  bool HandleActionClearFocusEvent();
-  bool HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp);
-  bool HandleActionBackEvent();
-  bool HandleActionEnableEvent();
-  bool HandleActionDisableEvent();
-  bool HandleActionScrollUpEvent();
-  bool HandleActionScrollDownEvent();
-  bool HandleActionPageLeftEvent();
-  bool HandleActionPageRightEvent();
-  bool HandleActionPageUpEvent();
-  bool HandleActionPageDownEvent();
-  bool HandleActionMoveToFirstEvent();
-  bool HandleActionMoveToLastEvent();
-  bool HandleActionReadFromTopEvent();
-  bool HandleActionReadFromNextEvent();
-  bool HandleActionZoomEvent();
-  bool HandleActionReadPauseResumeEvent();
-  bool HandleActionStartStopEvent();
-
-private:
-
-  bool mIsEnabled;
-  Dali::AccessibilityActionHandler* mActionHandler;
-  Dali::AccessibilityGestureHandler* mGestureHandler;
-  Vector2 mReadPosition;
-
-  static Dali::AccessibilityAdaptor mToolkitAccessibilityAdaptor;
-};
-
-Dali::AccessibilityAdaptor AccessibilityAdaptor::mToolkitAccessibilityAdaptor;
-
-
-Dali::AccessibilityAdaptor AccessibilityAdaptor::Get()
-{
-  if( !mToolkitAccessibilityAdaptor )
-  {
-    mToolkitAccessibilityAdaptor = Dali::AccessibilityAdaptor( new Dali::Internal::Adaptor::AccessibilityAdaptor() );
-  }
-  return mToolkitAccessibilityAdaptor;
-}
-
-AccessibilityAdaptor::AccessibilityAdaptor()
-: mIsEnabled(false),
-  mActionHandler(NULL),
-  mGestureHandler(NULL),
-  mReadPosition( 0.0f, 0.0f )
-{
-}
-
-AccessibilityAdaptor::~AccessibilityAdaptor()
-{
-}
-
-Vector2 AccessibilityAdaptor::GetReadPosition() const
-{
-  return mReadPosition;
-}
-
-void AccessibilityAdaptor::MockSetReadPosition( Vector2& position )
-{
-  mReadPosition = position;
-}
-
-bool AccessibilityAdaptor::IsEnabled() const
-{
-  return mIsEnabled;
-}
-
-void AccessibilityAdaptor::SendPanGesture( const AccessibilityGestureEvent& panEvent )
-{
-  mGestureHandler->HandlePanGesture( panEvent );
-}
-
-void AccessibilityAdaptor::SetActionHandler(Dali::AccessibilityActionHandler& handler)
-{
-  mActionHandler = &handler;
-}
-
-void AccessibilityAdaptor::SetGestureHandler(Dali::AccessibilityGestureHandler& handler)
-{
-  mGestureHandler = &handler;
-}
-
-bool AccessibilityAdaptor::HandleActionNextEvent(bool allowEndFeedback)
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionNext( true );
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionPreviousEvent(bool allowEndFeedback)
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionPrevious( true );
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionActivateEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionActivate();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionRead( allowReadAgain );
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionReadNextEvent(bool allowEndFeedback)
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionReadNext( true );
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionReadPreviousEvent(bool allowEndFeedback)
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionReadPrevious( true );
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionUpEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionUp();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionDownEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionDown();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionClearFocusEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->ClearAccessibilityFocus();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp)
-{
-  if( mActionHandler )
-  {
-    Dali::TouchEvent touch = Integration::NewTouchEvent(timeStamp, point);
-    return mActionHandler->AccessibilityActionScroll( touch );
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionBackEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionBack();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionEnableEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->ChangeAccessibilityStatus();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionDisableEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->ChangeAccessibilityStatus();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionScrollUpEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionScrollUp();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionScrollDownEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionScrollDown();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionPageLeftEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionPageLeft();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionPageRightEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionPageRight();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionPageUpEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionPageUp();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionPageDownEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionPageDown();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionMoveToFirst();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionMoveToLast();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionReadFromTop();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionReadFromNext();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionZoomEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionZoom();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionReadPauseResume();
-  }
-  return false;
-}
-
-bool AccessibilityAdaptor::HandleActionStartStopEvent()
-{
-  if( mActionHandler )
-  {
-    return mActionHandler->AccessibilityActionStartStop();
-  }
-  return false;
-}
-
-static Internal::Adaptor::AccessibilityAdaptor& GetImplementation(Dali::AccessibilityAdaptor& adaptor)
-{
-  BaseObject& handle = adaptor.GetBaseObject();
-  return static_cast<Internal::Adaptor::AccessibilityAdaptor&>(handle);
-}
-
-static const Internal::Adaptor::AccessibilityAdaptor& GetImplementation(const Dali::AccessibilityAdaptor& adaptor)
-{
-  const BaseObject& handle = adaptor.GetBaseObject();
-  return static_cast<const Internal::Adaptor::AccessibilityAdaptor&>(handle);
-}
-
-
-} // namespace Adaptor
-} // namespace Internal
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-AccessibilityAdaptor::AccessibilityAdaptor()
-{
-}
-
-AccessibilityAdaptor AccessibilityAdaptor::Get()
-{
-  return Internal::Adaptor::AccessibilityAdaptor::Get();
-}
-
-AccessibilityAdaptor::~AccessibilityAdaptor()
-{
-}
-
-// Methods:
-
-Vector2 AccessibilityAdaptor::GetReadPosition() const
-{
-  return Internal::Adaptor::GetImplementation(*this).GetReadPosition();
-}
-
-bool AccessibilityAdaptor::IsEnabled() const
-{
-  return Internal::Adaptor::GetImplementation(*this).IsEnabled();
-}
-
-void AccessibilityAdaptor::SetActionHandler(AccessibilityActionHandler& handler)
-{
-  Internal::Adaptor::GetImplementation(*this).SetActionHandler(handler);
-}
-
-void AccessibilityAdaptor::SetGestureHandler(AccessibilityGestureHandler& handler)
-{
-  Internal::Adaptor::GetImplementation(*this).SetGestureHandler(handler);
-}
-
-bool AccessibilityAdaptor::HandleActionNextEvent(bool allowEndFeedback)
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionNextEvent(allowEndFeedback);
-}
-
-bool AccessibilityAdaptor::HandleActionPreviousEvent(bool allowEndFeedback)
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionPreviousEvent(allowEndFeedback);
-}
-
-bool AccessibilityAdaptor::HandleActionActivateEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionActivateEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionReadEvent( x, y, allowReadAgain );
-}
-
-bool AccessibilityAdaptor::HandleActionReadNextEvent(bool allowEndFeedback)
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionReadNextEvent(allowEndFeedback);
-}
-
-bool AccessibilityAdaptor::HandleActionReadPreviousEvent(bool allowEndFeedback)
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionReadPreviousEvent(allowEndFeedback);
-}
-
-bool AccessibilityAdaptor::HandleActionUpEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionUpEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionDownEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionDownEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionClearFocusEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionClearFocusEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp)
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionScrollEvent(point, timeStamp);
-}
-
-bool AccessibilityAdaptor::HandleActionBackEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionBackEvent();
-}
-
-void AccessibilityAdaptor::HandleActionEnableEvent()
-{
-  Internal::Adaptor::GetImplementation(*this).HandleActionEnableEvent();
-}
-
-void AccessibilityAdaptor::HandleActionDisableEvent()
-{
-  Internal::Adaptor::GetImplementation(*this).HandleActionDisableEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionScrollUpEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionScrollUpEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionScrollDownEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionScrollDownEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionPageLeftEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionPageLeftEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionPageRightEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionPageRightEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionPageUpEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionPageUpEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionPageDownEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionPageDownEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToFirstEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToLastEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromTopEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromNextEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionZoomEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionZoomEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionReadPauseResumeEvent();
-}
-
-bool AccessibilityAdaptor::HandleActionStartStopEvent()
-{
-  return Internal::Adaptor::GetImplementation(*this).HandleActionStartStopEvent();
-}
-
-AccessibilityAdaptor::AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor* adaptor )
-: BaseHandle( adaptor )
-{
-}
-
-} // namespace Dali
-
-
-namespace Test
-{
-namespace AccessibilityAdaptor
-{
-
-// Mock setup:
-
-void MockSetReadPosition( Dali::AccessibilityAdaptor adaptor, Dali::Vector2& position )
-{
-  Dali::Internal::Adaptor::GetImplementation(adaptor).MockSetReadPosition( position );
-}
-
-void SetEnabled( Dali::AccessibilityAdaptor adaptor, bool enabled )
-{
-  Dali::Internal::Adaptor::GetImplementation(adaptor).SetEnabled(enabled);
-}
-
-void SendPanGesture( Dali::AccessibilityAdaptor adaptor, const Dali::AccessibilityGestureEvent& panEvent )
-{
-  Dali::Internal::Adaptor::GetImplementation(adaptor).SendPanGesture( panEvent );
-}
-
-} // namespace AccessibilityAdaptor
-} // namespace Test
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h
deleted file mode 100644 (file)
index a463baf..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef DALI_TEST_TOOLKIT_ACCESSIBILITY_ADAPTOR_H
-#define DALI_TEST_TOOLKIT_ACCESSIBILITY_ADAPTOR_H
-
-/*
- * Copyright (c) 2019 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 <dali/devel-api/adaptor-framework/accessibility-adaptor.h>
-#include <dali/devel-api/adaptor-framework/accessibility-gesture-event.h>
-
-namespace Test
-{
-namespace AccessibilityAdaptor
-{
-
-void MockSetReadPosition( Dali::AccessibilityAdaptor adaptor, Dali::Vector2& position );
-void SetEnabled( Dali::AccessibilityAdaptor adaptor, bool enabled);
-void SendPanGesture( Dali::AccessibilityAdaptor adaptor, const Dali::AccessibilityGestureEvent& panEvent );
-
-} // namespace AccessibilityAdaptor
-} // namespace Test
-
-#endif // DALI_TEST_TOOLKIT_ACCESSIBILITY_ADAPTOR_H
index 5dbbe76..1fe86c3 100644 (file)
 #include <dali/integration-api/debug.h>
 #include <dali/integration-api/scene.h>
 #include <test-application.h>
+#include <toolkit-test-application.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
@@ -364,6 +341,24 @@ 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 )
index 3e3a0d2..48173fd 100644 (file)
@@ -21,6 +21,7 @@
 // INTERNAL INCLUDES
 #include <dali-test-suite-utils.h>
 #include <dali/devel-api/text-abstraction/font-client.h>
+#include <dali/devel-api/adaptor-framework/accessibility-impl.h>
 #include <dali/integration-api/adaptor-framework/adaptor.h>
 #include <toolkit-adaptor-impl.h>
 #include <toolkit-lifecycle-controller.h>
@@ -46,6 +47,7 @@ ToolkitTestApplication::ToolkitTestApplication( size_t surfaceWidth, size_t surf
 
   // Core needs to be initialized next before we start the adaptor
   InitializeCore();
+  Accessibility::Accessible::SetObjectRegistry(mCore->GetObjectRegistry());
 
   // This will also emit the window created signals
   AdaptorImpl::GetImpl( *mAdaptor ).Start( *mMainWindow );
index 66527da..49a4c6f 100644 (file)
 
 // INTERNAL INCLUDES
 #include <dali-test-suite-utils.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <toolkit-adaptor-impl.h>
+#include <dali/devel-api/adaptor-framework/accessibility.h>
+#include "test-application.h"
+
+//#undef assert
 
 namespace Dali
 {
diff --git a/automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp b/automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp
deleted file mode 100644 (file)
index f0dcd1f..0000000
+++ /dev/null
@@ -1,2333 +0,0 @@
-/*
- * Copyright (c) 2020 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 <iostream>
-#include <stdlib.h>
-
-#include <dali-toolkit/dali-toolkit.h>
-#include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
-
-#include <dali-toolkit-test-suite-utils.h>
-#include <toolkit-accessibility-adaptor.h>
-#include <dummy-control.h>
-
-using namespace Dali;
-using namespace Toolkit;
-
-
-void utc_dali_toolkit_accessibility_manager_startup(void)
-{
-  test_return_value = TET_UNDEF;
-}
-
-void utc_dali_toolkit_accessibility_manager_cleanup(void)
-{
-  test_return_value = TET_PASS;
-}
-
-
-namespace
-{
-
-// Functors to test whether focus changed signal is emitted when the focus is changed
-class FocusChangedCallback : public Dali::ConnectionTracker
-{
-public:
-  FocusChangedCallback(bool& signalReceived)
-  : mSignalVerified(signalReceived),
-    mOriginalFocusedActor(),
-    mCurrentFocusedActor()
-  {
-  }
-
-  void Callback(Actor originalFocusedActor, Actor currentFocusedActor)
-  {
-    tet_infoline("Verifying FocusChangedCallback()");
-
-    if(originalFocusedActor == mCurrentFocusedActor)
-    {
-      mSignalVerified = true;
-    }
-
-    mOriginalFocusedActor = originalFocusedActor;
-    mCurrentFocusedActor = currentFocusedActor;
-  }
-
-  void Reset()
-  {
-    mSignalVerified = false;
-  }
-
-  bool& mSignalVerified;
-  Actor mOriginalFocusedActor;
-  Actor mCurrentFocusedActor;
-};
-
-// Functors to test whether focus overshot signal is emitted when there is no way to move focus further.
-class FocusOvershotCallback : public Dali::ConnectionTracker
-{
-public:
-  FocusOvershotCallback(bool& signalReceived)
-  : mSignalVerified(signalReceived),
-    mCurrentFocusedActor(),
-    mFocusOvershotDirection(Toolkit::AccessibilityManager::OVERSHOT_NEXT)
-  {
-  }
-
-  void Callback(Actor currentFocusedActor, Toolkit::AccessibilityManager::FocusOvershotDirection direction)
-  {
-    tet_infoline("Verifying FocusOvershotCallback()");
-
-    if(currentFocusedActor == mCurrentFocusedActor && direction == mFocusOvershotDirection)
-    {
-      mSignalVerified = true;
-    }
-  }
-
-  void Reset()
-  {
-    mSignalVerified = false;
-  }
-
-  bool& mSignalVerified;
-  Actor mCurrentFocusedActor;
-  Toolkit::AccessibilityManager::FocusOvershotDirection mFocusOvershotDirection;
-};
-
-// Functor to test whether focused actor activated signal is emitted.
-class FocusedActorActivatedCallback : public Dali::ConnectionTracker
-{
-public:
-  FocusedActorActivatedCallback()
-  {
-  }
-
-  void Callback(Actor activatedActor)
-  {
-    tet_infoline("Verifying FocusedActorActivatedCallback()");
-  }
-};
-
-} // namespace
-
-
-int UtcDaliAccessibilityManagerGet(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerGet");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  AccessibilityManager newManager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(newManager);
-
-  // Check that accessibility manager is a singleton
-  DALI_TEST_CHECK(manager == newManager);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSetAndGetAccessibilityAttribute(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSetAndGetAccessibilityAttribute");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Actor actor = Actor::New();
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL) == "");
-
-  manager.SetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL, "Description");
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL) == "Description");
-
-  manager.SetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL, "New description");
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL) == "New description");
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSetAndGetFocusOrder(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSetAndGetFocusOrder");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Actor first = Actor::New();
-  Actor second = Actor::New();
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 0);
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 0);
-
-  // Set the focus order and description for the first actor
-  manager.SetFocusOrder(first, 1);
-  manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Set the focus order and description for the second actor
-  manager.SetFocusOrder(second, 2);
-  manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // check that the focus order of the first actor is changed
-  manager.SetFocusOrder(first, 2);
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 2);
-  // make sure the change of focus order doesn't affect the actor's description
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // check that the focus order of the second actor is increased to 3
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 3);
-  // make sure the change of focus order doesn't affect the actor's description
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // check that the focus order of the second actor is changed to 1
-  manager.SetFocusOrder(second, 1);
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 1);
-  // make sure the change of focus order doesn't affect the actor's description
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  // Set the focus order and description for the third actor
-  Actor third = Actor::New();
-  manager.SetFocusOrder(third, 1);
-  manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
-  DALI_TEST_CHECK(manager.GetFocusOrder(third) == 1);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // check that the focus order of the second actor is increased to 2.
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
-  // make sure the change of focus order doesn't affect the actor's description
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // check that the focus order of the first actor is increased to 3.
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 3);
-  // make sure the change of focus order doesn't affect the actor's description
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerGenerateNewFocusOrder(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerGenerateNewFocusOrder");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  DALI_TEST_CHECK(1 == manager.GenerateNewFocusOrder());
-  DALI_TEST_CHECK(1 == manager.GenerateNewFocusOrder());
-
-  Actor first = Actor::New();
-  Actor second = Actor::New();
-
-  // Set the focus order for the first actor
-  manager.SetFocusOrder(first, 1);
-  manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
-
-  //Test for new focus order
-  DALI_TEST_CHECK(2 == manager.GenerateNewFocusOrder());
-
-  // Set the focus order for the first actor
-  manager.SetFocusOrder(second, 2);
-  manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerGetActorByFocusOrder(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerGetActorByFocusOrder");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  // Create the actors and set their focus orders
-  Actor first = Actor::New();
-  manager.SetFocusOrder(first, 1);
-
-  Actor second = Actor::New();
-  manager.SetFocusOrder(second, 2);
-
-  Actor third = Actor::New();
-  manager.SetFocusOrder(third, 3);
-
-  // Check that we get an empty handle as no actor is added to the stage yet.
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(1) == Actor());
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(2) == Actor());
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(3) == Actor());
-
-  // Add the actors to the stage
-  application.GetScene().Add(first);
-  application.GetScene().Add(second);
-  application.GetScene().Add(third);
-
-  // Check that we get an empty handle because focus order 0 means undefined.
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(0) == Actor());
-
-  // Check that we get correct actors for the specified focus orders
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(1) == first);
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(2) == second);
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(3) == third);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  // Change the focus order of the third actor to 1
-  manager.SetFocusOrder(third, 1);
-
-  // Check that we still get correct actors after changing their focus orders
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(1) == third);
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(2) == first);
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(3) == second);
-
-  // Check that we get an empty handle because no actor has a focus order of 4
-  DALI_TEST_CHECK(manager.GetActorByFocusOrder(4) == Actor());
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSetAndGetCurrentFocusActor(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSetAndGetCurrentFocusActor");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  // Create the first actor and add it to the stage
-  Actor first = Actor::New();
-  manager.SetFocusOrder(first, 1);
-  application.GetScene().Add(first);
-
-  // Create the second actor and add it to the stage
-  Actor second = Actor::New();
-  manager.SetFocusOrder(second, 2);
-  application.GetScene().Add(second);
-
-  // Create the third actor but don't add it to the stage
-  Actor third = Actor::New();
-  manager.SetFocusOrder(third, 3);
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Check that it will fail to set focus on an invalid actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(Actor()) == false);
-
-  // Check that the focus is set on the first actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-
-  // Check that the focus is set on the second actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-
-  // Check that it will fail to set focus on the third actor as it's not in the stage
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
-
-  // Add the third actor to the stage
-  application.GetScene().Add(third);
-
-  // make the third actor invisible
-  third.SetProperty( Actor::Property::VISIBLE,false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Check that it will fail to set focus on the third actor as it's invisible
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
-
-  // Make the third actor visible
-  third.SetProperty( Actor::Property::VISIBLE,true);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Make the third actor not focusable
-  Property::Index propertyActorFocusable = third.GetPropertyIndex("focusable");
-  third.SetProperty(propertyActorFocusable, false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Check that it will fail to set focus on the third actor as it's not focusable
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
-
-  // Make the third actor focusable
-  third.SetProperty(propertyActorFocusable, true);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Check that the focus is successfully moved to the third actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
-
-  // Make the current focused actor to be not focusable by setting its focus order to be 0
-  manager.SetFocusOrder(third, 0);
-
-  // Check that the focus is automatically cleared
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Set the focus order of the third actor again
-  manager.SetFocusOrder(third, 3);
-
-  // Check that the third actor can be focused successfully now
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerGetCurrentFocusGroup(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerGetCurrentFocusGroup");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  // Create an actor with two child actors and add it to the stage
-  Actor parent = Actor::New();
-  Actor firstChild = Actor::New();
-  Actor secondChild = Actor::New();
-  parent.Add(firstChild);
-  parent.Add(secondChild);
-  application.GetScene().Add(parent);
-
-  // Create three actors and add them as the children of the first child actor
-  Actor firstGrandChild = Actor::New();
-  Actor secondGrandChild = Actor::New();
-  Actor thirdGrandChild = Actor::New();
-  firstChild.Add(firstGrandChild);
-  firstChild.Add(secondGrandChild);
-  firstChild.Add(thirdGrandChild);
-
-  // Set focus order to the actors
-  manager.SetFocusOrder(parent, 1);
-  manager.SetFocusOrder(firstChild, 2);
-  manager.SetFocusOrder(firstGrandChild, 3);
-  manager.SetFocusOrder(secondGrandChild, 4);
-  manager.SetFocusOrder(thirdGrandChild, 5);
-  manager.SetFocusOrder(secondChild, 6);
-
-  // Set the parent and the first child actor as focus groups
-  manager.SetFocusGroup(parent, true);
-  DALI_TEST_CHECK(manager.IsFocusGroup(parent) == true);
-
-  // Set focus to the first grand child actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(firstGrandChild) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
-
-  // The current focus group should be the parent, As it is the immediate parent which is also a focus group.
-  DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == parent);
-
-  manager.SetFocusGroup(firstChild, true);
-  DALI_TEST_CHECK(manager.IsFocusGroup(firstChild) == true);
-
-  // The current focus group should be the firstChild, As it is the immediate parent which is also a focus group.
-  DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == firstChild);
-
-  manager.SetFocusGroup(firstGrandChild, true);
-  DALI_TEST_CHECK(manager.IsFocusGroup(firstGrandChild) == true);
-
-  // The current focus group should be itself, As it is also a focus group.
-  DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == firstGrandChild);
-
-  // Set focus to the second grand child actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(secondGrandChild) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondGrandChild);
-
-  // The current focus group should be the firstChild, As it is the immediate parent which is also a
-  // focus group for the current focus actor.
-  DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == firstChild);
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerGetCurrentFocusOrder(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerGetCurrentFocusOrder");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  Actor first = Actor::New();
-  application.GetScene().Add(first);
-
-  Actor second = Actor::New();
-  application.GetScene().Add(second);
-
-  Actor third = Actor::New();
-  application.GetScene().Add(third);
-
-  // Set the focus order and description for the first actor
-  manager.SetFocusOrder(first, 1);
-  manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Set the focus order and description for the second actor
-  manager.SetFocusOrder(second, 2);
-  manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // Set the focus order and description for the second actor
-  manager.SetFocusOrder(third, 3);
-  manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
-  DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 0);
-
-  // Set the focus on the first actor and test
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 1);
-
-  // Move the focus forward to the second actor and test
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 2);
-
-  // Move the focus forward to the third actor and test
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 3);
-
-  // Clear focus and test
-  manager.ClearFocus();
-  DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 0);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerMoveFocusForward(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerMoveFocusForward");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-  accAdaptor.HandleActionNextEvent(true);
-
-  Actor first = Actor::New();
-  application.GetScene().Add(first);
-
-  Actor second = Actor::New();
-  application.GetScene().Add(second);
-
-  Actor third = Actor::New();
-  application.GetScene().Add(third);
-
-  // Set the focus order and description for the first actor
-  manager.SetFocusOrder(first, 1);
-  manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Set the focus order and description for the second actor
-  manager.SetFocusOrder(second, 2);
-  manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // Set the focus order and description for the second actor
-  manager.SetFocusOrder(third, 3);
-  manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
-  DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Set the focus on the first actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Test the non-wrapped move first
-  manager.SetWrapMode(false);
-  DALI_TEST_CHECK(manager.GetWrapMode() == false);
-
-  // Move the focus forward to the second actor
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // Move the focus forward to the third actor
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Check that it will fail to move the focus forward again as the third actor is the last
-  // focusable actor in the focus chain
-  manager.MoveFocusForward();
-  // The focus should still be set on the third actor
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Now test the wrapped move
-  manager.SetWrapMode(true);
-  DALI_TEST_CHECK(manager.GetWrapMode() == true);
-
-  // Move the focus forward recursively and this time the first actor should be focused
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Make the second actor not focusable
-  Property::Index propertyActorFocusable = second.GetPropertyIndex("focusable");
-  second.SetProperty(propertyActorFocusable, false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Move the focus forward and check that the second actor should be skipped and
-  // the third actor should be focused now.
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Make the first actor invisible
-  first.SetProperty( Actor::Property::VISIBLE,false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Move the focus forward and check that the first actor should be skipped as it's
-  // invisible and the second actor should also be skipped as it's not focusable,
-  // so the focus will still be on the third actor
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Make the third actor invisible so that no actor can be focused.
-  third.SetProperty( Actor::Property::VISIBLE,false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Check that the focus move is failed as all the three actors can not be focused
-  manager.MoveFocusForward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerMoveFocusBackward(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerMoveFocusBackward");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  Actor first = Actor::New();
-  application.GetScene().Add(first);
-
-  Actor second = Actor::New();
-  application.GetScene().Add(second);
-
-  Actor third = Actor::New();
-  application.GetScene().Add(third);
-
-  // Set the focus order and description for the first actor
-  manager.SetFocusOrder(first, 1);
-  manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Set the focus order and description for the second actor
-  manager.SetFocusOrder(second, 2);
-  manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
-  DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // Set the focus order and description for the second actor
-  manager.SetFocusOrder(third, 3);
-  manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
-  DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Set the focus on the third actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Test the non-wrapped move first
-  manager.SetWrapMode(false);
-  DALI_TEST_CHECK(manager.GetWrapMode() == false);
-
-  // Move the focus backward to the second actor
-  manager.MoveFocusBackward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
-
-  // Move the focus backward to the first actor
-  manager.MoveFocusBackward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Check that it will fail to move the focus backward again as the first actor is the first
-  // focusable actor in the focus chain
-  manager.MoveFocusBackward();
-  // The focus should still be set on the first actor
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Now test the wrapped move
-  manager.SetWrapMode(true);
-  DALI_TEST_CHECK(manager.GetWrapMode() == true);
-
-  // Move the focus backward recursively and this time the third actor should be focused
-  manager.MoveFocusBackward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
-
-  // Make the second actor not focusable
-  Property::Index propertyActorFocusable = second.GetPropertyIndex("focusable");
-  second.SetProperty(propertyActorFocusable, false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Move the focus backward and check that the second actor should be skipped and
-  // the first actor should be focused now.
-  manager.MoveFocusBackward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Make the third actor invisible
-  third.SetProperty( Actor::Property::VISIBLE,false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Move the focus backward and check that the third actor should be skipped as it's
-  // invisible and the second actor should also be skipped as it's not focusable,
-  // so the focus will still be on the first actor
-  manager.MoveFocusBackward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-
-  // Make the first actor invisible so that no actor can be focused.
-  first.SetProperty( Actor::Property::VISIBLE,false);
-  // flush the queue and render once
-  application.SendNotification();
-  application.Render();
-
-  // Check that the focus move is failed as all the three actors can not be focused
-  manager.MoveFocusBackward();
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerClearFocus(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerClearFocus");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  // Create the first actor and add it to the stage
-  Actor first = Actor::New();
-  manager.SetFocusOrder(first, 1);
-  application.GetScene().Add(first);
-
-  // Create the second actor and add it to the stage
-  Actor second = Actor::New();
-  manager.SetFocusOrder(second, 2);
-  application.GetScene().Add(second);
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Check that the focus is set on the first actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-
-  // Check that the focus is set on the second actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-
-  // Clear the focus
-  manager.ClearFocus();
-
-  // Check that no actor is being focused now.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerReset(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerReset");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  // Create the first actor and add it to the stage
-  Actor first = Actor::New();
-  manager.SetFocusOrder(first, 1);
-  application.GetScene().Add(first);
-
-  // Create the second actor and add it to the stage
-  Actor second = Actor::New();
-  manager.SetFocusOrder(second, 2);
-  application.GetScene().Add(second);
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Check that the focus is set on the first actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-
-  // Check that the focus is set on the second actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-
-  // Clear the focus
-  manager.Reset();
-
-  // Check that no actor is being focused now and the focus order of actors have been cleared
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 0);
-  DALI_TEST_CHECK(manager.GetFocusOrder(first) == 0);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerFocusGroup(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerFocusGroup");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  // Create an actor with two child actors and add it to the stage
-  Actor parent = Actor::New();
-  Actor firstChild = Actor::New();
-  Actor secondChild = Actor::New();
-  parent.Add(firstChild);
-  parent.Add(secondChild);
-  application.GetScene().Add(parent);
-
-  // Create three actors and add them as the children of the first child actor
-  Actor firstGrandChild = Actor::New();
-  Actor secondGrandChild = Actor::New();
-  Actor thirdGrandChild = Actor::New();
-  firstChild.Add(firstGrandChild);
-  firstChild.Add(secondGrandChild);
-  firstChild.Add(thirdGrandChild);
-
-  // Set focus order to the actors
-  manager.SetFocusOrder(parent, 1);
-  manager.SetFocusOrder(firstChild, 2);
-  manager.SetFocusOrder(firstGrandChild, 3);
-  manager.SetFocusOrder(secondGrandChild, 4);
-  manager.SetFocusOrder(thirdGrandChild, 5);
-  manager.SetFocusOrder(secondChild, 6);
-
-  // Set the parent and the first child actor as focus groups
-  manager.SetFocusGroup(parent, true);
-  DALI_TEST_CHECK(manager.IsFocusGroup(parent) == true);
-
-  // The focus group of the parent should be itself, as it is set to be a focus group.
-  DALI_TEST_CHECK(manager.GetFocusGroup(parent) == parent);
-
-  // The focus group of the firstChild should be its parent, as it is the immediate parent which is also a group.
-  DALI_TEST_CHECK(manager.GetFocusGroup(firstChild) == parent);
-
-  manager.SetFocusGroup(firstChild, true);
-  DALI_TEST_CHECK(manager.IsFocusGroup(firstChild) == true);
-
-  // The focus group of the firstChild should be itself, as it is set to be a focus group now.
-  DALI_TEST_CHECK(manager.GetFocusGroup(firstChild) == firstChild);
-
-  // Enable wrap mode for focus movement.
-  manager.SetWrapMode(true);
-  DALI_TEST_CHECK(manager.GetWrapMode() == true);
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Check that the focus is set on the parent actor.
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(parent) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == parent);
-
-  // Check that group mode is disabled.
-  DALI_TEST_CHECK(manager.GetGroupMode() == false);
-
-  // Check that the focus movement is wrapped as normal.
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondGrandChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == thirdGrandChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == parent);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
-
-  // Enable the group mode.
-  manager.SetGroupMode(true);
-  DALI_TEST_CHECK(manager.GetGroupMode() == true);
-
-  // Check that the focus movement is now limited to the current focus group.
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondGrandChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == thirdGrandChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstChild);
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSetAndGetFocusIndicator(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSetAndGetFocusIndicator");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Actor defaultFocusIndicatorActor = manager.GetFocusIndicatorActor();
-  DALI_TEST_CHECK(defaultFocusIndicatorActor);
-
-  Actor newFocusIndicatorActor = Actor::New();
-  manager.SetFocusIndicatorActor(newFocusIndicatorActor);
-  DALI_TEST_CHECK(manager.GetFocusIndicatorActor() == newFocusIndicatorActor);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSetAndGetFocusIndicatorWithFocusedActor(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSetAndGetFocusIndicatorWithFocusedActor");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  Actor defaultFocusIndicatorActor = manager.GetFocusIndicatorActor();
-  DALI_TEST_CHECK(defaultFocusIndicatorActor);
-
-  Actor focusedActor = Actor::New();
-  application.GetScene().Add( focusedActor );
-
-  application.SendNotification();
-  application.Render();
-
-  DALI_TEST_EQUALS( focusedActor.GetChildCount(), 0u, TEST_LOCATION );
-
-  manager.SetFocusOrder( focusedActor, 1 );
-  manager.SetCurrentFocusActor( focusedActor );
-
-  DALI_TEST_EQUALS( focusedActor.GetChildCount(), 1u, TEST_LOCATION );
-  DALI_TEST_CHECK( focusedActor.GetChildAt(0) == defaultFocusIndicatorActor );
-
-  Actor newFocusIndicatorActor = Actor::New();
-  manager.SetFocusIndicatorActor( newFocusIndicatorActor );
-  DALI_TEST_CHECK(manager.GetFocusIndicatorActor() == newFocusIndicatorActor);
-  DALI_TEST_EQUALS( focusedActor.GetChildCount(), 1u, TEST_LOCATION );
-  DALI_TEST_CHECK( focusedActor.GetChildAt(0) == newFocusIndicatorActor );
-
-  // Disable Accessibility
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, false );
-  accAdaptor.HandleActionEnableEvent();
-
-  DALI_TEST_EQUALS( focusedActor.GetChildCount(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSignalFocusChanged(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSignalFocusChanged");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  bool signalVerified = false;
-  FocusChangedCallback callback(signalVerified);
-  manager.FocusChangedSignal().Connect( &callback, &FocusChangedCallback::Callback );
-
-  // Create the first actor and add it to the stage
-  Actor first = Actor::New();
-  manager.SetFocusOrder(first, 1);
-  application.GetScene().Add(first);
-
-  // Create the second actor and add it to the stage
-  Actor second = Actor::New();
-  manager.SetFocusOrder(second, 2);
-  application.GetScene().Add(second);
-
-  // Check that no actor is being focused yet.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-
-  // Check that the focus is set on the first actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(callback.mSignalVerified);
-  callback.Reset();
-
-  // Check that the focus is set on the second actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-  DALI_TEST_CHECK(callback.mSignalVerified);
-  callback.Reset();
-
-  // Clear the focus
-  manager.ClearFocus();
-
-  // Check that no actor is being focused now.
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
-  DALI_TEST_CHECK(callback.mSignalVerified);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSignalFocusOvershot(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSignalFocusOvershot");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  bool signalVerified = false;
-  FocusOvershotCallback callback(signalVerified);
-  manager.FocusOvershotSignal().Connect(&callback, &FocusOvershotCallback::Callback);
-
-  // Create the first actor and add it to the stage
-  Actor first = Actor::New();
-  manager.SetFocusOrder(first, 1);
-  application.GetScene().Add(first);
-
-  // Create the second actor and add it to the stage
-  Actor second = Actor::New();
-  manager.SetFocusOrder(second, 2);
-  application.GetScene().Add(second);
-
-  // Check that the wrap mode is disabled
-  DALI_TEST_CHECK(manager.GetWrapMode() == false);
-
-  // Check that the focus is set on the first actor
-  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-
-  // Check that the focus is moved to the second actor successfully.
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-
-  // Check that the forward focus movement is overshot.
-  callback.mCurrentFocusedActor = second;
-  callback.mFocusOvershotDirection = Toolkit::AccessibilityManager::OVERSHOT_NEXT;
-  DALI_TEST_CHECK(manager.MoveFocusForward() == false);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
-  DALI_TEST_CHECK(signalVerified);
-  callback.Reset();
-
-  // Enable the wrap mode
-  manager.SetWrapMode(true);
-  DALI_TEST_CHECK(manager.GetWrapMode() == true);
-
-  // Check that the forward focus movement is wrapped and no overshot happens.
-  DALI_TEST_CHECK(manager.MoveFocusForward() == true);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(signalVerified == false);
-
-  // Disable the wrap mode
-  manager.SetWrapMode(false);
-  DALI_TEST_CHECK(manager.GetWrapMode() == false);
-
-  // Check that the backward focus movement is overshot.
-  callback.mCurrentFocusedActor = first;
-  callback.mFocusOvershotDirection = Toolkit::AccessibilityManager::OVERSHOT_PREVIOUS;
-  DALI_TEST_CHECK(manager.MoveFocusBackward() == false);
-  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
-  DALI_TEST_CHECK(signalVerified);
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerSignalFocusedActorActivated(void)
-{
-  ToolkitTestApplication application;
-
-  tet_infoline(" UtcDaliAccessibilityManagerSignalFocusedActorActivated");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK(manager);
-
-  FocusedActorActivatedCallback callback;
-  manager.FocusedActorActivatedSignal().Connect(&callback, &FocusedActorActivatedCallback::Callback);
-  DALI_TEST_CHECK(true);
-
-  END_TEST;
-}
-
-// Note: No negative test for GetReadPosition as it will always return something.
-int UtcDaliAccessibilityManagerGetReadPositionP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline(" UtcDaliAccessibilityManagerGetReadPositionP");
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  Vector2 readPosition( manager.GetReadPosition() );
-  DALI_TEST_EQUALS( readPosition.x, 0.0f, Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  DALI_TEST_EQUALS( readPosition.y, 0.0f, Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  END_TEST;
-}
-
-// Functor to test if an accessibility signal has been called.
-class AccessibilityManagerSignalHandler : public Dali::ConnectionTracker
-{
-public:
-  AccessibilityManagerSignalHandler() :
-    mCalls( 0 )
-  {
-  }
-
-  bool Callback( AccessibilityManager& accessibilityManager )
-  {
-    mCalls++;
-    tet_infoline( "Signal called" );
-    return true;
-  }
-
-  unsigned int GetCalls() const
-  {
-    return mCalls;
-  }
-
-private:
-  unsigned int mCalls;  ///< Keeps track of how many times the signal has been called.
-};
-
-int UtcDaliAccessibilityManagerStatusChangedSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerStatusChangedSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.StatusChangedSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  // Cause a state change.
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionEnableEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerStatusChangedSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerStatusChangedSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.StatusChangedSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionNextSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionNextSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionNextEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionNextSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionNextSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionPreviousSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionPreviousSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionPreviousEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionPreviousSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionPreviousSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionActivateSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionActivateSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  Dali::Toolkit::PushButton button = Dali::Toolkit::PushButton::New();
-  button.SetProperty( Actor::Property::SIZE, Vector2(480, 800) );
-  application.GetScene().Add(button);
-  manager.SetFocusOrder( button, 1 );
-  manager.SetCurrentFocusActor( button );
-
-  manager.ActionActivateSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionActivateEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionActivateSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionActivateSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionActivateSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionReadSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionReadSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionReadSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionReadEvent( 100.0f, 200.0f, true );
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionReadSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionReadSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionReadSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionOverSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionOverSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionOverSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  // Note that the ActionOverSignal is provoked by a read even when "allow read again" is set to false.
-  accessibilityAdaptor.HandleActionReadEvent( 100.0f, 200.0f, false );
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionOverSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionOverSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionOverSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionReadNextSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionReadNextSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionReadNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionReadNextEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionReadNextSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionReadNextSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionReadNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionReadPreviousSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionReadPreviousSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionReadPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionReadPreviousEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionReadPreviousSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionReadPreviousSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionReadPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionUpSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionUpSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accessibilityAdaptor, true );
-  accessibilityAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  DummyControl dummyControl = DummyControl::New(true);
-  dummyControl.SetProperty( Actor::Property::SIZE, Vector2(480, 800) );
-  manager.SetFocusOrder( dummyControl, 1 );
-  application.GetScene().Add( dummyControl );
-  manager.SetCurrentFocusActor( dummyControl );
-
-  accessibilityAdaptor.HandleActionUpEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionUpSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionUpSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionDownSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionDownSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accessibilityAdaptor, true );
-  accessibilityAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::Toolkit::PushButton button = Dali::Toolkit::PushButton::New();
-  button.SetProperty( Actor::Property::SIZE, Vector2(480, 800) );
-  application.GetScene().Add(button);
-  manager.SetFocusOrder( button, 1 );
-  manager.SetCurrentFocusActor( button );
-
-  accessibilityAdaptor.HandleActionDownEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionDownSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionDownSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionClearFocusSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionClearFocusSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionClearFocusSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionClearFocusEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionClearFocusSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionClearFocusSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionClearFocusSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionBackSignalP(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionBackSignalP" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
-  Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
-  accAdaptor.HandleActionEnableEvent();
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionBackSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
-
-  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
-  accessibilityAdaptor.HandleActionBackEvent();
-
-  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliAccessibilityManagerActionBackSignalN(void)
-{
-  ToolkitTestApplication application;
-  tet_infoline( " UtcDaliAccessibilityManagerActionBackSignalN" );
-
-  AccessibilityManagerSignalHandler callback;
-
-  AccessibilityManager manager = AccessibilityManager::Get();
-  DALI_TEST_CHECK( manager );
-
-  manager.ActionBackSignal().Connect(