automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.cpp

   1 #include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/accessibility-test-utils.h>
   2 #include <dali-toolkit-test-suite-utils.h>
   3
   4 namespace Dali {
   5     namespace Accessibility {
   6
   7         using MethodType = TestDBusWrapper::MethodType;
   8         using MessagePtr = DBusWrapper::MessagePtr;
   9
  10         void TestEnableSC(bool b) {
  11             static bool firstTime = true;
  12             if (b && firstTime) {
  13                 firstTime = false;
  14                 auto bridge = Accessibility::Bridge::GetCurrentBridge();
  15                 Dali::Stage stage = Dali::Stage::GetCurrent();
  16                 auto accessible = Accessibility::Accessible::Get( stage.GetRootLayer() );
  17                 bridge->SetApplicationChild( accessible );
  18                 bridge->SetApplicationName( "TestApp" );
  19                 bridge->Initialize();
  20
  21                 static bool ScreenReaderEnabled = false;
  22                 static bool IsEnabled = false;
  23
  24                 auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
  25
  26                 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 {
  27                     auto reply = wr->newReplyMessage(m);
  28                     wr->Encode(reply, std::tuple<TestDBusWrapper::Variant<bool>>{ ScreenReaderEnabled });
  29                     return reply;
  30                 };
  31                 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 {
  32                     auto reply = wr->newReplyMessage(m);
  33                     wr->Encode(reply, std::tuple<TestDBusWrapper::Variant<bool>>{ IsEnabled });
  34                     return reply;
  35                 };
  36                 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 {
  37                     auto reply = wr->newReplyMessage(m);
  38                     wr->Encode(reply, std::tuple<const char*>{ "bus" });
  39                     return reply;
  40                 };
  41                 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 {
  42                     auto reply = wr->newReplyMessage(m);
  43                     wr->Encode(reply, std::tuple<Address>{ {"bus", "root"} });
  44                     return reply;
  45                 };
  46                 wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "PropertyChange", MethodType::Method}] =
  47                 [wr](const MessagePtr &m) -> MessagePtr {
  48                     return wr->newReplyMessage(m);
  49                 };
  50                 wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "StateChanged", MethodType::Method}] =
  51                 [wr](const MessagePtr &m) -> MessagePtr {
  52                     return wr->newReplyMessage(m);
  53                 };
  54                 wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "BoundsChanged", MethodType::Method}] =
  55                 [wr](const MessagePtr &m) -> MessagePtr {
  56                     return wr->newReplyMessage(m);
  57                 };
  58                 wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "ActiveDescendantChanged", MethodType::Method}] =
  59                 [wr](const MessagePtr &m) -> MessagePtr {
  60                     return wr->newReplyMessage(m);
  61                 };
  62                 wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "TextChanged", MethodType::Method}] =
  63                 [wr](const MessagePtr &m) -> MessagePtr {
  64                     return wr->newReplyMessage(m);
  65                 };
  66                 wr->testMethods[std::tuple<std::string, std::string, std::string, MethodType>{"/org/a11y/atspi/accessible", "org.a11y.atspi.Event.Object", "TextCaretMoved", MethodType::Method}] =
  67                 [wr](const MessagePtr &m) -> MessagePtr {
  68                     return wr->newReplyMessage(m);
  69                 };
  70             }
  71             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
  72             wr->fromTestChangeProperty("/org/a11y/bus", "org.a11y.Status", "ScreenReaderEnabled", b);
  73         }
  74
  75         std::vector<Address> TestGetChildren(const Address &adr)
  76         {
  77             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
  78             auto chs = wr->fromTestCall<std::vector<Address>>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetChildren", std::tuple<>());
  79             return std::move(std::get<0>(chs));
  80         }
  81
  82         std::string TestGetName(const Address &adr)
  83         {
  84             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
  85             auto name = wr->fromTestGet<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "Name");
  86             return name;
  87         }
  88
  89         std::string TestGetDescription(const Address &adr)
  90         {
  91             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
  92             auto description = wr->fromTestGet<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "Description");
  93             return description;
  94         }
  95
  96         uint32_t TestGetRole(const Address &adr)
  97         {
  98             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
  99             auto chs = wr->fromTestCall<uint32_t>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetRole", std::tuple<>());
 100             return std::move(std::get<0>(chs));
 101         }
 102
 103         std::string TestGetRoleName(const Address &adr)
 104         {
 105             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 106             auto chs = wr->fromTestCall<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetRoleName", std::tuple<>());
 107             return std::move(std::get<0>(chs));
 108         }
 109
 110         Address TestGetParent(const Address &adr)
 111         {
 112             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 113             auto chs = wr->fromTestGet< Address >(adr.GetPath(), "org.a11y.atspi.Accessible", "Parent");
 114             return chs;
 115         }
 116
 117         std::string TestGetLocalizedRoleName(const Address &adr)
 118         {
 119             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 120             auto chs = wr->fromTestCall<std::string>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetLocalizedRoleName", std::tuple<>());
 121             return std::move(std::get<0>(chs));
 122         }
 123
 124         std::array< uint32_t, 2 > TestGetStates(const Address &adr)
 125         {
 126             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 127             auto chs = wr->fromTestCall<std::array< uint32_t, 2 >>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetState", std::tuple<>());
 128             return std::move(std::get<0>(chs));
 129         }
 130
 131         std::unordered_map< std::string, std::string > TestGetAttributes(const Address &adr)
 132         {
 133             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 134             auto chs = wr->fromTestCall<std::unordered_map< std::string, std::string >>(adr.GetPath(), "org.a11y.atspi.Accessible", "GetAttributes", std::tuple<>());
 135             return std::move(std::get<0>(chs));
 136         }
 137
 138         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)
 139         {
 140             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 141             auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Accessible", "DoGesture",
 142                 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 ));
 143             return std::move(std::get<0>(chs));
 144         }
 145
 146         std::vector< std::tuple< uint32_t, std::vector< Dali::Accessibility::Address > > > TestGetRelationSet(const Address &adr)
 147         {
 148             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 149             auto chs = wr->fromTestCall< std::vector< std::tuple< uint32_t, std::vector< Dali::Accessibility::Address > > > >(adr.GetPath(), "org.a11y.atspi.Accessible", "GetRelationSet", std::tuple<>());
 150             return std::move(std::get<0>(chs));
 151         }
 152
 153         Address TestGetChildAtIndex(const Address &adr, int index)
 154         {
 155             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 156             auto chs = wr->fromTestCall< Address >(adr.GetPath(), "org.a11y.atspi.Accessible", "GetChildAtIndex", std::tuple< int >( index ));
 157             return std::move(std::get<0>(chs));
 158         }
 159
 160         ComponentLayer TestGetLayer(const Address &adr)
 161         {
 162             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 163             auto chs = wr->fromTestCall< Dali::Accessibility::ComponentLayer >(adr.GetPath(), "org.a11y.atspi.Component", "GetLayer", std::tuple<>());
 164             return std::move(std::get<0>(chs));
 165         }
 166
 167         int TestGetIndexInParent(const Address &adr)
 168         {
 169             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 170             auto chs = wr->fromTestCall< int >(adr.GetPath(), "org.a11y.atspi.Accessible", "GetIndexInParent", std::tuple<>());
 171             return std::move(std::get<0>(chs));
 172         }
 173
 174         bool TestGrabFocus(const Address &adr)
 175         {
 176             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 177             auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Component", "GrabFocus", std::tuple<>());
 178             return std::move(std::get<0>(chs));
 179         }
 180
 181         bool TestGrabHighlight(const Address &adr)
 182         {
 183             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 184             auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Component", "GrabHighlight", std::tuple<>());
 185             return std::move(std::get<0>(chs));
 186         }
 187
 188         bool TestClearHighlight(const Address &adr)
 189         {
 190             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 191             auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Component", "ClearHighlight", std::tuple<>());
 192             return std::move(std::get<0>(chs));
 193         }
 194
 195         std::tuple< int32_t, int32_t, int32_t, int32_t > TestGetExtents(const Address &adr)
 196         {
 197             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 198             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));
 199             return std::move(std::get<0>(chs));
 200         }
 201
 202         int TestGetMdiZOrder(const Address &adr)
 203         {
 204             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 205             auto chs = wr->fromTestCall< int16_t >(adr.GetPath(), "org.a11y.atspi.Component", "GetMDIZOrder", std::tuple<>());
 206             return std::move(std::get<0>(chs));
 207         }
 208
 209         double TestGetAlpha(const Address &adr)
 210         {
 211             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 212             auto chs = wr->fromTestCall< double >(adr.GetPath(), "org.a11y.atspi.Component", "GetAlpha", std::tuple<>());
 213             return std::move(std::get<0>(chs));
 214         }
 215
 216         std::string TestGetActionName( const Address &adr, size_t index )
 217         {
 218             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 219             auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetName", std::tuple< int32_t >( index ));
 220             return std::move(std::get<0>(chs));
 221         }
 222
 223         std::string TestGetLocalizedActionName( const Address &adr, size_t index )
 224         {
 225             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 226             auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetLocalizedName", std::tuple< int32_t >( index ));
 227             return std::move(std::get<0>(chs));
 228         }
 229
 230         size_t TestGetActionCount( const Address &adr )
 231         {
 232             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 233             auto count = wr->fromTestGet< int32_t >(adr.GetPath(), "org.a11y.atspi.Action", "NActions");
 234             return count;
 235         }
 236
 237         bool TestDoAction ( const Address &adr, size_t index )
 238         {
 239             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 240             auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Action", "DoAction", std::tuple< int32_t >( index ));
 241             return std::move(std::get<0>(chs));
 242         }
 243
 244         bool TestDoAction ( const Address &adr, const std::string& name )
 245         {
 246             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 247             auto chs = wr->fromTestCall< bool >(adr.GetPath(), "org.a11y.atspi.Action", "DoActionName", std::tuple< std::string >( name ));
 248             return std::move(std::get<0>(chs));
 249         }
 250
 251         std::string TestGetActionKeyBinding ( const Address &adr, size_t index )
 252         {
 253             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 254             auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetKeyBinding", std::tuple< int32_t >( index ));
 255             return std::move(std::get<0>(chs));
 256         }
 257
 258         std::string TestGetActionDescription ( const Address &adr, size_t index )
 259         {
 260             auto wr = static_cast<TestDBusWrapper*>(DBusWrapper::Installed());
 261             auto chs = wr->fromTestCall< std::string >(adr.GetPath(), "org.a11y.atspi.Action", "GetDescription", std::tuple< int32_t >( index ));
 262             return std::move(std::get<0>(chs));
 263         }
 264
 265
 266         void printTree(const Address &root, size_t depth)
 267         {
 268             auto name = TestGetName(root);
 269             printf("%10s", root.GetPath().c_str());
 270             for(unsigned int i = 0; i < depth; ++i) printf("  ");
 271             printf("%s\n", name.c_str());
 272             auto chs = TestGetChildren(root);
 273             for(auto &c : chs)
 274                 printTree(c, depth + 1);
 275         }
 276
 277         bool Find( const std::vector< std::string > &collection, const std::string &key)
 278         {
 279             for ( auto& it : collection)
 280                 if( it == key )
 281                     return true;
 282             return false;
 283         }
 284     }
 285 }