From 4962e32a18913f9f8b64c0d5569f157921465910 Mon Sep 17 00:00:00 2001 From: Wonki Kim Date: Mon, 7 Sep 2020 16:30:43 +0900 Subject: [PATCH] refactor atspi related classes to mock atspi interface. this patch refactors atspi related classes to mock atspi interface. Change-Id: I2cfa273b29f4a8822ccb35364a9ce9977eeb9392 --- libaurum/inc/Accessibility/AccessibleNode.h | 23 ++- libaurum/inc/Accessibility/AccessibleWindow.h | 43 ++++- libaurum/inc/Comparer.h | 10 - .../Accessibility/AtspiAccessibleApplication.h | 20 +- .../inc/Impl/Accessibility/AtspiAccessibleNode.h | 6 - .../Impl/Accessibility/AtspiAccessibleWatcher.h | 16 +- .../inc/Impl/Accessibility/AtspiAccessibleWindow.h | 9 + .../Impl/Accessibility/MockAccessibleApplication.h | 46 ++++- .../inc/Impl/Accessibility/MockAccessibleNode.h | 53 +++++- .../inc/Impl/Accessibility/MockAccessibleWatcher.h | 30 ++- .../inc/Impl/Accessibility/MockAccessibleWindow.h | 27 ++- libaurum/inc/Impl/MockDeviceImpl.h | 205 ++++++++++++++++++++- libaurum/inc/Impl/TizenDeviceImpl.h | 173 +++++++++++++++++ libaurum/inc/PartialMatch.h | 6 + libaurum/inc/UiObject.h | 26 ++- libaurum/inc/UiSelector.h | 100 +++++++++- libaurum/src/Accessibility/AccessibleNode.cc | 11 +- libaurum/src/Accessibility/AccessibleWatcher.cc | 2 - libaurum/src/Accessibility/AccessibleWindow.cc | 2 +- libaurum/src/Comparer.cc | 20 +- .../src/Impl/Accessibility/AtspiAccessibleNode.cc | 13 +- .../Impl/Accessibility/AtspiAccessibleWatcher.cc | 116 ++++++------ .../Impl/Accessibility/AtspiAccessibleWindow.cc | 2 - .../Accessibility/MockAccessibleApplication.cc | 41 +---- .../src/Impl/Accessibility/MockAccessibleNode.cc | 33 ++-- .../Impl/Accessibility/MockAccessibleWatcher.cc | 48 +---- .../src/Impl/Accessibility/MockAccessibleWindow.cc | 15 +- libaurum/src/Impl/MockDeviceImpl.cc | 165 +++++++++++------ libaurum/src/PartialMatch.cc | 41 +++-- libaurum/src/UiDevice.cc | 4 +- libaurum/src/UiObject.cc | 20 +- libaurum/src/UiSelector.cc | 62 +++++-- .../src/Commands/FindElementCommand.cc | 2 +- protocol/examples/python/testInternal.py | 2 +- tests/ua_test.cpp | 8 +- 35 files changed, 1070 insertions(+), 330 deletions(-) diff --git a/libaurum/inc/Accessibility/AccessibleNode.h b/libaurum/inc/Accessibility/AccessibleNode.h index d85c2f2..4e56478 100644 --- a/libaurum/inc/Accessibility/AccessibleNode.h +++ b/libaurum/inc/Accessibility/AccessibleNode.h @@ -55,13 +55,6 @@ enum class NodeFeatureProperties { INVALID = 0X2000, }; -class IAccessibleNode { -public: - virtual ~IAccessibleNode() = 0; - - -}; - /** * @brief AccessibleNode Class * @since_tizen 5.5 @@ -122,7 +115,13 @@ public: * @brief TBD * @since_tizen 5.5 */ - std::string getRes() const; + std::string getId() const; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::string getAutomationId() const; /** * @brief TBD @@ -307,7 +306,12 @@ protected: /** * @brief TBD */ - std::string mRes; + std::string mId; + + /** + * @brief TBD + */ + std::string mAutomationId; /** * @brief TBD @@ -333,5 +337,4 @@ protected: * @brief TBD */ int mFeatureProperty; - }; \ No newline at end of file diff --git a/libaurum/inc/Accessibility/AccessibleWindow.h b/libaurum/inc/Accessibility/AccessibleWindow.h index 44e87c6..9720557 100644 --- a/libaurum/inc/Accessibility/AccessibleWindow.h +++ b/libaurum/inc/Accessibility/AccessibleWindow.h @@ -9,18 +9,57 @@ class AccessibleApplication; class AccessibleWindow { public: + /** + * @brief TBD + * @since_tizen 6.0 + */ AccessibleWindow(std::shared_ptr app, std::shared_ptr node); + + /** + * @brief TBD + * @since_tizen 6.0 + */ virtual ~AccessibleWindow(); public: + /** + * @brief TBD + * @since_tizen 6.0 + */ std::string getTitle(void); + + /** + * @brief TBD + * @since_tizen 6.0 + */ bool isShowing(); + + /** + * @brief TBD + * @since_tizen 6.0 + */ bool isActive(); + /** + * @brief TBD + * @since_tizen 6.0 + */ std::shared_ptr getApplication(void); - std::shared_ptr getNode(void); + + /** + * @brief TBD + * @since_tizen 6.0 + */ + std::shared_ptr getAccessibleNode(void); private: - std::shared_ptr mNode; + /** + * @brief TBD + */ std::shared_ptr mApp; + + /** + * @brief TBD + */ + std::shared_ptr mNode; }; \ No newline at end of file diff --git a/libaurum/inc/Comparer.h b/libaurum/inc/Comparer.h index 99b37ea..f6fc9dd 100644 --- a/libaurum/inc/Comparer.h +++ b/libaurum/inc/Comparer.h @@ -65,16 +65,6 @@ private: private: /** * @brief TBD - * @since_tizen 5.5 - */ - /* std::unique_ptr accept(const AccessibleNode *node, - const std::shared_ptr selector, - const int &index, const int &depth, - const int &relDepth); -*/ -private: - /** - * @brief TBD */ const std::shared_ptr mDevice; diff --git a/libaurum/inc/Impl/Accessibility/AtspiAccessibleApplication.h b/libaurum/inc/Impl/Accessibility/AtspiAccessibleApplication.h index 78208af..1ee5592 100644 --- a/libaurum/inc/Impl/Accessibility/AtspiAccessibleApplication.h +++ b/libaurum/inc/Impl/Accessibility/AtspiAccessibleApplication.h @@ -6,12 +6,28 @@ class AtspiAccessibleApplication : public AccessibleApplication, public std::enable_shared_from_this { public: + /** + * @brief TBD + * @since_tizen 6.0 + */ AtspiAccessibleApplication(std::shared_ptr node); + + /** + * @brief TBD + * @since_tizen 6.0 + */ virtual ~AtspiAccessibleApplication(); public: + /** + * @brief TBD + * @since_tizen 6.0 + */ std::vector> getWindows(void) override; - //std::vector> getActiveWindows(void) override; - std::string getPackageName(void) override; + /** + * @brief TBD + * @since_tizen 6.0 + */ + std::string getPackageName(void) override; }; \ No newline at end of file diff --git a/libaurum/inc/Impl/Accessibility/AtspiAccessibleNode.h b/libaurum/inc/Impl/Accessibility/AtspiAccessibleNode.h index 3121f8c..85fe9be 100644 --- a/libaurum/inc/Impl/Accessibility/AtspiAccessibleNode.h +++ b/libaurum/inc/Impl/Accessibility/AtspiAccessibleNode.h @@ -85,11 +85,5 @@ private: * @brief TBD * @since_tizen 5.5 */ - //static std::map mNodeMap; - - /** - * @brief TBD - * @since_tizen 5.5 - */ AtspiAccessible* mNode; }; \ No newline at end of file diff --git a/libaurum/inc/Impl/Accessibility/AtspiAccessibleWatcher.h b/libaurum/inc/Impl/Accessibility/AtspiAccessibleWatcher.h index 93ded42..79bdc65 100644 --- a/libaurum/inc/Impl/Accessibility/AtspiAccessibleWatcher.h +++ b/libaurum/inc/Impl/Accessibility/AtspiAccessibleWatcher.h @@ -98,19 +98,6 @@ public: */ virtual std::vector> getApplications(void) const override; - /** - * @brief TBD - * @since_tizen 5.5 - */ - //std::shared_ptr getRootNode() const override; - - /** - * @brief TBD - * @since_tizen 5.5 - */ - //std::vector> getTopNode() const override; - - public: /** * @brief TBD @@ -212,6 +199,9 @@ private: */ std::set mWindowSet; + /** + * @brief TBD + */ std::map mWindowAppMap; }; \ No newline at end of file diff --git a/libaurum/inc/Impl/Accessibility/AtspiAccessibleWindow.h b/libaurum/inc/Impl/Accessibility/AtspiAccessibleWindow.h index 6883bf6..95631e7 100644 --- a/libaurum/inc/Impl/Accessibility/AtspiAccessibleWindow.h +++ b/libaurum/inc/Impl/Accessibility/AtspiAccessibleWindow.h @@ -3,7 +3,16 @@ class AtspiAccessibleWindow : public AccessibleWindow { public: + /** + * @brief TBD + * @since_tizen 6.0 + */ AtspiAccessibleWindow(std::shared_ptr app, std::shared_ptr node); + + /** + * @brief TBD + * @since_tizen 6.0 + */ ~AtspiAccessibleWindow(); }; \ No newline at end of file diff --git a/libaurum/inc/Impl/Accessibility/MockAccessibleApplication.h b/libaurum/inc/Impl/Accessibility/MockAccessibleApplication.h index dc4359e..76a3caa 100644 --- a/libaurum/inc/Impl/Accessibility/MockAccessibleApplication.h +++ b/libaurum/inc/Impl/Accessibility/MockAccessibleApplication.h @@ -1,23 +1,65 @@ #pragma once #include "AccessibleApplication.h" +#include "MockAccessibleWindow.h" +#include "MockAccessibleNode.h" #include class MockAccessibleApplication : public AccessibleApplication, public std::enable_shared_from_this { public: + /** + * @brief TBD + * @since tizen_6.0 + */ MockAccessibleApplication(std::shared_ptr node); + + /** + * @brief TBD + * @since tizen_6.0 + */ + MockAccessibleApplication(std::shared_ptr parent, std::string text,std::string pkg,std::string role, std::string res,std::string type,std::string style,Rect boundingBox,int supportingIfaces,int featureProperty); + + /** + * @brief TBD + * @since tizen_6.0 + */ virtual ~MockAccessibleApplication(); public: + /** + * @brief TBD + * @since tizen_6.0 + */ std::vector> getWindows(void) override; - //std::vector> getActiveWindows(void) override; + + /** + * @brief TBD + * @since tizen_6.0 + */ std::string getPackageName(void) override; public: + /** + * @brief TBD + * @since tizen_6.0 + */ void addWindow(std::shared_ptr window); + + /** + * @brief TBD + * @since tizen_6.0 + */ + std::shared_ptr addWindow(std::string title, std::string widget, Rect geometry, int properties); + + /** + * @brief TBD + * @since tizen_6.0 + */ void clearWindows(void); private: + /** + * @brief TBD + */ std::vector> mWindowList; - }; \ No newline at end of file diff --git a/libaurum/inc/Impl/Accessibility/MockAccessibleNode.h b/libaurum/inc/Impl/Accessibility/MockAccessibleNode.h index 98bbb44..80e8ad3 100644 --- a/libaurum/inc/Impl/Accessibility/MockAccessibleNode.h +++ b/libaurum/inc/Impl/Accessibility/MockAccessibleNode.h @@ -1,15 +1,16 @@ #pragma once #include "AccessibleNode.h" +#include #include -class MockAccessibleNode : public AccessibleNode { +class MockAccessibleNode : public AccessibleNode, public std::enable_shared_from_this { public: /** * @brief TBD * @since_tizen 5.5 */ - MockAccessibleNode(std::shared_ptr parent, std::string text,std::string pkg,std::string role, std::string res,std::string type,std::string style,Rect boundingBox,int supportingIfaces,int featureProperty); + MockAccessibleNode(std::shared_ptr parent, std::string text,std::string pkg,std::string role, std::string id, std::string type,std::string style, std::string automationId, Rect boundingBox,int supportingIfaces,int featureProperty); /** * @brief TBD @@ -87,17 +88,55 @@ public: * @since_tizen 5.5 */ void addChild(std::shared_ptr child); + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::shared_ptr addChild(std::string text, std::string pkg, std::string role, std::string res, std::string type, std::string style,std::string automationId, Rect geometry, int ifaces, int properties); + + /** + * @brief TBD + * @since_tizen 5.5 + */ void clearChildren(void); + + /** + * @brief TBD + * @since_tizen 5.5 + */ void addAction(std::string action); + + /** + * @brief TBD + * @since_tizen 5.5 + */ void clearActions(void); - void setProperties(std::string text,std::string pkg, std::string role, std::string res, std::string type, std::string style, Rect boundingBox, int supportingIfaces, int featureProperty); -private: + /** + * @brief TBD + * @since_tizen 5.5 + */ + void setProperties(std::string text,std::string pkg, std::string role, std::string res, std::string type, std::string style,std::string automationId, Rect boundingBox, int supportingIfaces, int featureProperty); +private: + /** + * @brief TBD + */ std::shared_ptr mParentNode; - std::vector> mChildrenList; - std::set mActionSet; -}; + /** + * @brief TBD + */ + std::vector> mChildrenList; + /** + * @brief TBD + */ + std::set mActionSet; + /** + * @brief TBD + */ + std::mutex mLock; +}; \ No newline at end of file diff --git a/libaurum/inc/Impl/Accessibility/MockAccessibleWatcher.h b/libaurum/inc/Impl/Accessibility/MockAccessibleWatcher.h index e3476d2..2d523d3 100644 --- a/libaurum/inc/Impl/Accessibility/MockAccessibleWatcher.h +++ b/libaurum/inc/Impl/Accessibility/MockAccessibleWatcher.h @@ -2,18 +2,25 @@ #include "AccessibleNode.h" #include "AccessibleWatcher.h" +#include "MockAccessibleApplication.h" + #include #include #include -#include #include -#include -#include - class MockAccessibleWatcher : public AccessibleWatcher { public: + /** + * @brief TBD + * @since_tizen 5.5 + */ MockAccessibleWatcher(); + + /** + * @brief TBD + * @since_tizen 5.5 + */ virtual ~MockAccessibleWatcher(); public: @@ -29,7 +36,6 @@ public: */ virtual std::shared_ptr getApplicationAt(int index) const override; - /** * @brief TBD * @since_tizen 5.5 @@ -37,14 +43,26 @@ public: virtual std::vector> getApplications(void) const override; public: + /** + * @brief TBD + * @since_tizen 5.5 + */ void addApplication(std::shared_ptr application); + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::shared_ptr addApplication(std::string pkgName, Rect geometry, int ifaces, int properties); + private: + /** + * @brief TBD + */ std::vector> mApplicationList; /** * @brief TBD */ std::mutex mLock; - }; \ No newline at end of file diff --git a/libaurum/inc/Impl/Accessibility/MockAccessibleWindow.h b/libaurum/inc/Impl/Accessibility/MockAccessibleWindow.h index e7ec0b5..a0264e9 100644 --- a/libaurum/inc/Impl/Accessibility/MockAccessibleWindow.h +++ b/libaurum/inc/Impl/Accessibility/MockAccessibleWindow.h @@ -1,8 +1,33 @@ #pragma once #include "AccessibleWindow.h" +#include "MockAccessibleNode.h" + +class MockAccessibleApplication; class MockAccessibleWindow : public AccessibleWindow { public: - MockAccessibleWindow(std::shared_ptr app, std::shared_ptr node); + /** + * @brief TBD + * @since_tizen 5.5 + */ + MockAccessibleWindow(std::shared_ptr app, std::shared_ptr node); + + /** + * @brief TBD + * @since_tizen 5.5 + */ ~MockAccessibleWindow(); + +public: + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::shared_ptr addNode(std::string text, std::string pkg, std::string role, std::string res, std::string type, std::string style, std::string automationId, Rect geometry, int ifaces, int properties); + +private: + /** + * @brief TBD + */ + std::shared_ptr mMockNode; }; \ No newline at end of file diff --git a/libaurum/inc/Impl/MockDeviceImpl.h b/libaurum/inc/Impl/MockDeviceImpl.h index dd35e6f..43ad464 100644 --- a/libaurum/inc/Impl/MockDeviceImpl.h +++ b/libaurum/inc/Impl/MockDeviceImpl.h @@ -3,60 +3,263 @@ #include "IDevice.h" #include +#include +#include +#include +#include +enum class MockKeyType { + BACK, + HOME, + MENU, + VOLUP, + VOLDOWN, + POWER, + KEY +}; + +struct TouchData { int x; int y; long long stamp1; long long stamp2;}; class MockDeviceImpl : public IDevice { public: + /** + * @brief TBD + * @since_tizen 5.5 + */ MockDeviceImpl(); + + /** + * @brief TBD + * @since_tizen 5.5 + */ ~MockDeviceImpl(); + /** + * @brief TBD + * @since_tizen 5.5 + */ bool click(const int x, const int y) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool click(const int x, const int y, const unsigned int intv) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ bool drag(const int sx, const int sy, const int ex, const int ey, const int steps, const int durationMs) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ int touchDown(const int x, const int y) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool touchMove(const int x, const int y, const int seq) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool touchUp(const int x, const int y, const int seq) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ bool wheelUp(int amount, const int durationMs) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool wheelDown(int amount, const int durationMs) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressBack(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressHome(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressMenu(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressVolUp(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressVolDown(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressPower(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressKeyCode(std::string keycode, KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool takeScreenshot(std::string path, float scale, int quality) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ long long getSystemTime(TimeRequestType type) override; protected: + /** + * @brief TBD + * @since_tizen 5.5 + */ bool strokeKeyCode(std::string keycode, unsigned int intv); + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressKeyCode(std::string keycode); + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool releaseKeyCode(std::string keycode); + /** + * @brief TBD + * @since_tizen 5.5 + */ int grabTouchSeqNumber(); + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool releaseTouchSeqNumber(int seq); private: + /** + * @brief TBD + * @since_tizen 5.5 + */ void startTimer(void); + + /** + * @brief TBD + * @since_tizen 5.5 + */ int stopTimer(void); -private: + /** + * @brief TBD + * @since_tizen 5.5 + */ + long long timeStamp(void); + +public: + /** + * @brief TBD + */ static const unsigned int INTV_CLICK = 5; + + /** + * @brief TBD + */ static const unsigned int INTV_SHORTSTROKE = 100; + + /** + * @brief TBD + */ static const unsigned int INTV_LONGSTROKE = 2000; + /** + * @brief TBD + */ static const unsigned int INTV_MINIMUM_DRAG_MS = 25; + + /** + * @brief TBD + */ static const unsigned int INTV_MINIMUM_USLEEP = 1000; + + /** + * @brief TBD + */ static const unsigned int MINIMUM_DURATION_DRAG = 100; + + /** + * @brief TBD + */ static const unsigned int MSEC_PER_SEC = 1000; + + /** + * @brief TBD + */ static const unsigned int MAX_FINGER_NUMBER = 2; + /** + * @brief TBD + */ struct timespec tStart; + + /** + * @brief TBD + */ bool isTimerStarted; + /** + * @brief TBD + */ std::set mTouchSeq; + +public: + /** + * @brief TBD + */ + std::map mTouchRelease; + + /** + * @brief TBD + */ + std::map mTouchDown; + + /** + * @brief TBD + */ + std::vector> mKeyDevice; + + /** + * @brief TBD + */ + int mWheelDevice; }; \ No newline at end of file diff --git a/libaurum/inc/Impl/TizenDeviceImpl.h b/libaurum/inc/Impl/TizenDeviceImpl.h index 6e4dca4..cf5b5cb 100644 --- a/libaurum/inc/Impl/TizenDeviceImpl.h +++ b/libaurum/inc/Impl/TizenDeviceImpl.h @@ -13,60 +13,233 @@ */ class TizenDeviceImpl : public IDevice { public: + /** + * @brief TBD + * @since_tizen 5.5 + */ TizenDeviceImpl(); + + /** + * @brief TBD + * @since_tizen 5.5 + */ ~TizenDeviceImpl(); + /** + * @brief TBD + * @since_tizen 5.5 + */ bool click(const int x, const int y) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool click(const int x, const int y, const unsigned int intv) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ bool drag(const int sx, const int sy, const int ex, const int ey, const int steps, const int durationMs) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ int touchDown(const int x, const int y) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool touchMove(const int x, const int y, const int seq) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool touchUp(const int x, const int y, const int seq) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ bool wheelUp(int amount, const int durationMs) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool wheelDown(int amount, const int durationMs) override; + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressBack(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressHome(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressMenu(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressVolUp(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressVolDown(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressPower(KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressKeyCode(std::string keycode, KeyRequestType type) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool takeScreenshot(std::string path, float scale, int quality) override; + + /** + * @brief TBD + * @since_tizen 5.5 + */ long long getSystemTime(TimeRequestType type) override; protected: + /** + * @brief TBD + * @since_tizen 5.5 + */ bool strokeKeyCode(std::string keycode, unsigned int intv); + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool pressKeyCode(std::string keycode); + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool releaseKeyCode(std::string keycode); + /** + * @brief TBD + * @since_tizen 5.5 + */ int grabTouchSeqNumber(); + + /** + * @brief TBD + * @since_tizen 5.5 + */ bool releaseTouchSeqNumber(int seq); private: + /** + * @brief TBD + * @since_tizen 5.5 + */ void startTimer(void); + + /** + * @brief TBD + * @since_tizen 5.5 + */ int stopTimer(void); private: + /** + * @brief TBD + */ efl_util_inputgen_h mFakeTouchHandle; + + /** + * @brief TBD + */ efl_util_inputgen_h mFakeKeyboardHandle; + + /** + * @brief TBD + */ efl_util_inputgen_h mFakeWheelHandle; + + /** + * @brief TBD + */ static const unsigned int INTV_CLICK = 5; + + /** + * @brief TBD + */ static const unsigned int INTV_SHORTSTROKE = 100; + + /** + * @brief TBD + */ static const unsigned int INTV_LONGSTROKE = 2000; + /** + * @brief TBD + */ static const unsigned int INTV_MINIMUM_DRAG_MS = 25; + + /** + * @brief TBD + */ static const unsigned int INTV_MINIMUM_USLEEP = 1000; + + /** + * @brief TBD + */ static const unsigned int MINIMUM_DURATION_DRAG = 100; + + /** + * @brief TBD + */ static const unsigned int MSEC_PER_SEC = 1000; + + /** + * @brief TBD + */ static const unsigned int MAX_FINGER_NUMBER = 2; + /** + * @brief TBD + */ struct timespec tStart; + + /** + * @brief TBD + */ bool isTimerStarted; + /** + * @brief TBD + */ std::set mTouchSeq; }; \ No newline at end of file diff --git a/libaurum/inc/PartialMatch.h b/libaurum/inc/PartialMatch.h index a4085c8..7248d58 100644 --- a/libaurum/inc/PartialMatch.h +++ b/libaurum/inc/PartialMatch.h @@ -78,6 +78,12 @@ private: * @brief TBD * @since_tizen 5.5 */ + static bool checkCriteria(const std::string *textA, const std::string textB, const bool *match); + + /** + * @brief TBD + * @since_tizen 5.5 + */ static bool checkCriteria(const bool *boolA, const bool boolB); private: diff --git a/libaurum/inc/UiObject.h b/libaurum/inc/UiObject.h index 538810e..6b9e0d0 100644 --- a/libaurum/inc/UiObject.h +++ b/libaurum/inc/UiObject.h @@ -10,11 +10,21 @@ #include class UiDevice; + +class Node : public std::enable_shared_from_this { +public: + Node(std::shared_ptr node, std::vector> children) + :mNode{node}, mChildren{children}{} + + std::shared_ptr mNode; + std::vector> mChildren; +}; + /** * @brief UiObject class * @since_tizen 5.5 */ -class UiObject : public ISearchable { +class UiObject : public ISearchable , public std::enable_shared_from_this { public: /** * @brief TBD @@ -119,13 +129,25 @@ public: * @brief TBD * @since_tizen 5.5 */ + std::shared_ptr getDescendant(); + + /** + * @brief TBD + * @since_tizen 5.5 + */ std::string getApplicationPackage() const; /** * @brief TBD * @since_tizen 5.5 */ - std::string getResourceName() const; + std::string getId() const; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::string getAutomationId() const; /** * @brief TBD diff --git a/libaurum/inc/UiSelector.h b/libaurum/inc/UiSelector.h index c65caf0..489aeb6 100644 --- a/libaurum/inc/UiSelector.h +++ b/libaurum/inc/UiSelector.h @@ -29,31 +29,43 @@ public: * @brief TBD * @since_tizen 5.5 */ - UiSelector *id(std::string text); + UiSelector *id(std::string text, bool match = true); /** * @brief TBD * @since_tizen 5.5 */ - UiSelector *text(std::string text); + UiSelector *automationid(std::string text, bool match = true); /** * @brief TBD * @since_tizen 5.5 */ - UiSelector *pkg(std::string text); + UiSelector *text(std::string text, bool match = true); /** * @brief TBD * @since_tizen 5.5 */ - UiSelector *type(std::string text); + UiSelector *pkg(std::string text, bool match = true); /** * @brief TBD * @since_tizen 5.5 */ - UiSelector *style(std::string text); + UiSelector *role(std::string text, bool match = true); + + /** + * @brief TBD + * @since_tizen 5.5 + */ + UiSelector *type(std::string text, bool match = true); + + /** + * @brief TBD + * @since_tizen 5.5 + */ + UiSelector *style(std::string text, bool match = true); /** * @brief TBD @@ -143,13 +155,13 @@ public: * @brief TBD * @since_tizen 5.5 */ - UiSelector *res(std::string text); + UiSelector *isVisible(bool cond); /** * @brief TBD * @since_tizen 5.5 */ - UiSelector *desc(std::string text); + UiSelector *isSelectable(bool cond); /** * @brief TBD @@ -157,6 +169,12 @@ public: */ UiSelector *hasChild(std::shared_ptr child); + /** + * @brief TBD + * @since_tizen 5.5 + */ + UiSelector *fromParent(std::shared_ptr parent); + public: /** * @brief TBD @@ -168,6 +186,18 @@ public: * @brief TBD * @since_tizen 5.5 */ + std::unique_ptr mAutomationId; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mRole; + + /** + * @brief TBD + * @since_tizen 5.5 + */ std::unique_ptr mText; /** @@ -192,6 +222,48 @@ public: * @brief TBD * @since_tizen 5.5 */ + std::unique_ptr mMatchId; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mMatchAutomationId; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mMatchRole; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mMatchText; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mMatchPkg; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mMatchType; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mMatchStyle; + + /** + * @brief TBD + * @since_tizen 5.5 + */ std::unique_ptr mMinDepth; /** @@ -264,11 +336,23 @@ public: * @brief TBD * @since_tizen 5.5 */ - std::unique_ptr mRes; + std::unique_ptr mIsvisible; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::unique_ptr mIsselectable; /** * @brief TBD * @since_tizen 5.5 */ std::vector> mChild; + + /** + * @brief TBD + * @since_tizen 5.5 + */ + std::shared_ptr mParent; }; \ No newline at end of file diff --git a/libaurum/src/Accessibility/AccessibleNode.cc b/libaurum/src/Accessibility/AccessibleNode.cc index 14de23f..0679aa3 100644 --- a/libaurum/src/Accessibility/AccessibleNode.cc +++ b/libaurum/src/Accessibility/AccessibleNode.cc @@ -12,7 +12,7 @@ AccessibleNode::~AccessibleNode() } AccessibleNode::AccessibleNode() - : mText{""}, mPkg{""}, mRole{""}, mRes{""}, mType{""}, mStyle{""}, + : mText{""}, mPkg{""}, mRole{""}, mId{""}, mType{""}, mStyle{""}, mBoundingBox{0,0,0,0}, mSupportingIfaces(0), mFeatureProperty(0) { } @@ -65,9 +65,14 @@ std::string AccessibleNode::getPkg() const return mPkg; } -std::string AccessibleNode::getRes() const +std::string AccessibleNode::getId() const { - return mRes; + return mId; +} + +std::string AccessibleNode::getAutomationId() const +{ + return mAutomationId; } std::string AccessibleNode::getRole() const diff --git a/libaurum/src/Accessibility/AccessibleWatcher.cc b/libaurum/src/Accessibility/AccessibleWatcher.cc index a689671..647d7e4 100644 --- a/libaurum/src/Accessibility/AccessibleWatcher.cc +++ b/libaurum/src/Accessibility/AccessibleWatcher.cc @@ -36,7 +36,6 @@ void AccessibleWatcher::printDbgInformation() const const AccessibleWatcher *AccessibleWatcher::getInstance(AccessibleWatcher *watcherImpl) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); static AccessibleWatcher *mInstance = nullptr; if (watcherImpl) { delete mInstance; @@ -52,7 +51,6 @@ const AccessibleWatcher *AccessibleWatcher::getInstance(AccessibleWatcher *watch #endif } } - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mInstance; } diff --git a/libaurum/src/Accessibility/AccessibleWindow.cc b/libaurum/src/Accessibility/AccessibleWindow.cc index 8de9d5a..437f141 100644 --- a/libaurum/src/Accessibility/AccessibleWindow.cc +++ b/libaurum/src/Accessibility/AccessibleWindow.cc @@ -30,7 +30,7 @@ std::shared_ptr AccessibleWindow::getApplication(void) return mApp; } -std::shared_ptr AccessibleWindow::getNode(void) +std::shared_ptr AccessibleWindow::getAccessibleNode(void) { return mNode; } \ No newline at end of file diff --git a/libaurum/src/Comparer.cc b/libaurum/src/Comparer.cc index ccf6138..f8abbd9 100644 --- a/libaurum/src/Comparer.cc +++ b/libaurum/src/Comparer.cc @@ -14,8 +14,7 @@ std::shared_ptr Comparer::findObject(const std::shared_ptr selector, const std::shared_ptr root) { - Comparer comparer(device, selector, true); - std::vector> ret = comparer.findObjects(root); + std::vector> ret = findObjects(device, selector, root); if (ret.size() > 0) return std::move(ret[0]); else @@ -26,9 +25,20 @@ std::vector> Comparer::findObjects(const std::sh const std::shared_ptr selector, const std::shared_ptr root) { - Comparer comparer(device, selector, false); - std::vector> ret = comparer.findObjects(root); - return ret; + Comparer comparer(device, selector, false); + + if (selector->mParent) { + auto ret = Comparer::findObjects(device, selector->mParent, root); + std::vector> merged{}; + + for (const auto &node : ret) { + auto tmp = comparer.findObjects(node); + std::move(std::begin(tmp), std::end(tmp), std::back_inserter(merged)); + } + return merged; + } + + return comparer.findObjects(root); } std::vector> Comparer::findObjects(const std::shared_ptr root) diff --git a/libaurum/src/Impl/Accessibility/AtspiAccessibleNode.cc b/libaurum/src/Impl/Accessibility/AtspiAccessibleNode.cc index a497533..00e530a 100644 --- a/libaurum/src/Impl/Accessibility/AtspiAccessibleNode.cc +++ b/libaurum/src/Impl/Accessibility/AtspiAccessibleNode.cc @@ -117,11 +117,11 @@ void AtspiAccessibleNode::refresh() #ifdef TIZEN gchar *uID = atspi_accessible_get_unique_id(mNode, NULL); if (uID) { - mRes = uID; + mId = uID; g_free(uID); } #else - mRes = std::string{"N/A"}; + mId = std::string{"N/A"}; #endif gchar *name = atspi_accessible_get_name(mNode, NULL); @@ -132,21 +132,23 @@ void AtspiAccessibleNode::refresh() GHashTable *attributes = atspi_accessible_get_attributes(mNode, NULL); char *t = (char*)g_hash_table_lookup(attributes, "type"); char *s = (char*)g_hash_table_lookup(attributes, "style"); + char *a = (char*)g_hash_table_lookup(attributes, "automationId"); if (t) mType = std::string(t); if (s) mStyle = std::string(s); + if (a) mAutomationId = std::string(a); free(t); free(s); + free(a); g_hash_table_unref(attributes); AtspiStateSet *st = atspi_accessible_get_state_set(mNode); GArray *states = atspi_state_set_get_states(st); - char *state_name = NULL; AtspiStateType stat; - for (int i = 0; states && (i < states->len); ++i) { + for (unsigned int i = 0; states && (i < states->len); ++i) { stat = g_array_index(states, AtspiStateType, i); setFeatureProperty(stat); } @@ -171,7 +173,6 @@ void AtspiAccessibleNode::refresh() std::vector AtspiAccessibleNode::getActions() const { std::vector result{}; - const char *name; AtspiAction *action; action = atspi_accessible_get_action_iface(mNode); @@ -192,7 +193,6 @@ std::vector AtspiAccessibleNode::getActions() const bool AtspiAccessibleNode::doAction(std::string actionName) { - const char *name; AtspiAction *action; action = atspi_accessible_get_action_iface(mNode); @@ -305,6 +305,7 @@ void AtspiAccessibleNode::setFeatureProperty(AtspiStateType type) case ATSPI_STATE_HAS_POPUP: case ATSPI_STATE_READ_ONLY: case ATSPI_STATE_LAST_DEFINED: + default: break; } } \ No newline at end of file diff --git a/libaurum/src/Impl/Accessibility/AtspiAccessibleWatcher.cc b/libaurum/src/Impl/Accessibility/AtspiAccessibleWatcher.cc index f82ae7a..5205072 100644 --- a/libaurum/src/Impl/Accessibility/AtspiAccessibleWatcher.cc +++ b/libaurum/src/Impl/Accessibility/AtspiAccessibleWatcher.cc @@ -18,17 +18,16 @@ static bool iShowingNode(AtspiAccessible *node) LOG_SCOPE_F(INFO, "isShowing %s", name); auto stateSet = atspi_accessible_get_state_set(node); - auto states = atspi_state_set_get_states(stateSet); if (atspi_state_set_contains(stateSet, ATSPI_STATE_ACTIVE) && atspi_state_set_contains(stateSet, ATSPI_STATE_SHOWING)) { LOG_F(INFO, "active and showing %p %s", node, name); free(name); - // TODO : free states and stateSet + g_object_unref(stateSet); return true; } free(name); - // TODO : free states and stateSet + g_object_unref(stateSet); return false; } @@ -191,7 +190,6 @@ void AtspiAccessibleWatcher::print_debug() LOG_F(INFO, "child:%p", acc); }); LOG_F(INFO, "------------------------------"); - } void AtspiAccessibleWatcher::onWindowActivated(AtspiAccessible *node, @@ -275,6 +273,60 @@ std::vector> AtspiAccessibleWatcher::getA return ret; } +bool AtspiAccessibleWatcher::removeFromActivatedList(AtspiAccessible *node) +{ + LOG_SCOPE_F(INFO,"remove from activelist node %p", node); + mActivatedWindowList.remove_if([&](auto &n) { return n == node; }); + + AtspiAccessible *app = atspi_accessible_get_application(node, NULL); + LOG_F(INFO, "node:%p, app:%p", node, app); + if (app) { + mActivatedApplicationList.remove_if([&](auto &n) { return n == app; }); + g_object_unref(app); + } + return true; +} + +bool AtspiAccessibleWatcher::addToActivatedList(AtspiAccessible *node) +{ + LOG_SCOPE_F(INFO,"add to activelist node %p", node); + mActivatedWindowList.remove_if([&](auto &n) { return n == node; }); + mActivatedWindowList.push_front(node); + + auto iter = mWindowSet.find(node); + if ( iter == mWindowSet.end()) mWindowSet.insert(node); + + AtspiAccessible *app = atspi_accessible_get_application(node, NULL); + LOG_F(INFO, "node:%p, app:%p", node, app); + if (app) { + mActivatedApplicationList.remove_if([&](auto &n) { if(n == app) { g_object_unref(app); return true;} else return false; }); + mActivatedApplicationList.push_front(app); + } + + return true; +} + +bool AtspiAccessibleWatcher::removeFromWindowSet(AtspiAccessible *node) +{ + removeFromActivatedList(node); + auto iter = mWindowSet.find(node); + if ( iter != mWindowSet.end()){ + mWindowSet.erase(node); + return true; + } + return false; +} + +bool AtspiAccessibleWatcher::addToWindowSet(AtspiAccessible *node) +{ + auto iter = mWindowSet.find(node); + if ( iter == mWindowSet.end()){ + mWindowSet.insert(node); + return true; + } + return false; +} + /* std::shared_ptr AtspiAccessibleWatcher::getRootNode() const { @@ -349,58 +401,4 @@ void AtspiAccessibleWatcher::clearWindowList() mWindowSet.clear(); } -*/ - -bool AtspiAccessibleWatcher::removeFromActivatedList(AtspiAccessible *node) -{ - LOG_SCOPE_F(INFO,"remove from activelist node %p", node); - mActivatedWindowList.remove_if([&](auto &n) { return n == node; }); - - AtspiAccessible *app = atspi_accessible_get_application(node, NULL); - LOG_F(INFO, "node:%p, app:%p", node, app); - if (app) { - mActivatedApplicationList.remove_if([&](auto &n) { return n == app; }); - g_object_unref(app); - } - return true; -} - -bool AtspiAccessibleWatcher::addToActivatedList(AtspiAccessible *node) -{ - LOG_SCOPE_F(INFO,"add to activelist node %p", node); - mActivatedWindowList.remove_if([&](auto &n) { return n == node; }); - mActivatedWindowList.push_front(node); - - auto iter = mWindowSet.find(node); - if ( iter == mWindowSet.end()) mWindowSet.insert(node); - - AtspiAccessible *app = atspi_accessible_get_application(node, NULL); - LOG_F(INFO, "node:%p, app:%p", node, app); - if (app) { - mActivatedApplicationList.remove_if([&](auto &n) { if(n == app) { g_object_unref(app); return true;} else return false; }); - mActivatedApplicationList.push_front(app); - } - - return true; -} - -bool AtspiAccessibleWatcher::removeFromWindowSet(AtspiAccessible *node) -{ - removeFromActivatedList(node); - auto iter = mWindowSet.find(node); - if ( iter != mWindowSet.end()){ - mWindowSet.erase(node); - return true; - } - return false; -} - -bool AtspiAccessibleWatcher::addToWindowSet(AtspiAccessible *node) -{ - auto iter = mWindowSet.find(node); - if ( iter == mWindowSet.end()){ - mWindowSet.insert(node); - return true; - } - return false; -} \ No newline at end of file +*/ \ No newline at end of file diff --git a/libaurum/src/Impl/Accessibility/AtspiAccessibleWindow.cc b/libaurum/src/Impl/Accessibility/AtspiAccessibleWindow.cc index d563df8..26ed203 100644 --- a/libaurum/src/Impl/Accessibility/AtspiAccessibleWindow.cc +++ b/libaurum/src/Impl/Accessibility/AtspiAccessibleWindow.cc @@ -4,10 +4,8 @@ AtspiAccessibleWindow::AtspiAccessibleWindow(std::shared_ptr app, std::shared_ptr node) : AccessibleWindow(app, node) { - } AtspiAccessibleWindow::~AtspiAccessibleWindow() { - } \ No newline at end of file diff --git a/libaurum/src/Impl/Accessibility/MockAccessibleApplication.cc b/libaurum/src/Impl/Accessibility/MockAccessibleApplication.cc index a4326dc..e4f0f34 100644 --- a/libaurum/src/Impl/Accessibility/MockAccessibleApplication.cc +++ b/libaurum/src/Impl/Accessibility/MockAccessibleApplication.cc @@ -9,57 +9,36 @@ MockAccessibleApplication::MockAccessibleApplication(std::shared_ptr node) : AccessibleApplication(node), mWindowList{} { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); } MockAccessibleApplication::~MockAccessibleApplication() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); } std::vector> MockAccessibleApplication::getWindows(void) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mWindowList; } -/* -std::vector> MockAccessibleApplication::getActiveWindows(void) -{ - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - - std::vector> ret{}; - - auto children = getWindows(); - - children.erase(std::remove_if(children.begin(), children.end(), [](auto child){ - return !(child->isActive()); // && child->isShowing() && child->isVisible()); - }), children.end()); - - LOG_SCOPE_F(INFO, "getActiveWindows app(%s) for %p, size:%d", getPackageName().c_str(), getAccessibleNode()->getRawHandler(), children.size()); - - // std::transform(children.begin(), children.end(), std::back_inserter(ret), - // [&](std::shared_ptr child) { - // return std::make_shared(this->shared_from_this(), child); - // } - // ); - return ret; -} -*/ std::string MockAccessibleApplication::getPackageName(void) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return "This.Is.Mock.Application"; } void MockAccessibleApplication::addWindow(std::shared_ptr window) { mWindowList.push_back(window); - // auto node = getAccessibleNode(); - // auto node2 = dynamic_cast>(node); - // node2->addChild(window->getNode()); } void MockAccessibleApplication::clearWindows(void) { mWindowList.clear(); -} \ No newline at end of file +} + +std::shared_ptr MockAccessibleApplication::addWindow(std::string title, std::string widget, Rect geometry, int properties) +{ + auto node = std::make_shared(nullptr, title, title, "window", "res",widget,"style", "", geometry, 0, properties); + auto win = std::make_shared(shared_from_this(), node); + this->addWindow(win); + return win; +} + diff --git a/libaurum/src/Impl/Accessibility/MockAccessibleNode.cc b/libaurum/src/Impl/Accessibility/MockAccessibleNode.cc index 0ce2788..4bf3980 100644 --- a/libaurum/src/Impl/Accessibility/MockAccessibleNode.cc +++ b/libaurum/src/Impl/Accessibility/MockAccessibleNode.cc @@ -1,54 +1,49 @@ #include "MockAccessibleNode.h" #include +#include -MockAccessibleNode::MockAccessibleNode(std::shared_ptr parent, std::string text, std::string pkg, std::string role, std::string res, std::string type, std::string style, Rect boundingBox, int supportingIfaces,int featureProperty) -: mParentNode(parent), mChildrenList{}, mActionSet{} +MockAccessibleNode::MockAccessibleNode(std::shared_ptr parent, std::string text, std::string pkg, std::string role, std::string res, std::string type, std::string style,std::string automationId, Rect boundingBox, int supportingIfaces,int featureProperty) +: mParentNode(parent), mChildrenList{}, mActionSet{}, mLock{} { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - setProperties(text,pkg,role,res,type,style,boundingBox, supportingIfaces, featureProperty); + setProperties(text,pkg,role,res,type,style,automationId, boundingBox, supportingIfaces, featureProperty); } MockAccessibleNode::~MockAccessibleNode() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); } int MockAccessibleNode::getChildCount() const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mChildrenList.size(); } std::shared_ptr MockAccessibleNode::getChildAt(int index) const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mChildrenList.at(index); } std::vector> MockAccessibleNode::getChildren() const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mChildrenList; } std::shared_ptr MockAccessibleNode::getParent() const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mParentNode; } void* MockAccessibleNode::getRawHandler(void) const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return (void*)0; } -void MockAccessibleNode::setProperties(std::string text,std::string pkg,std::string role,std::string res,std::string type,std::string style,Rect boundingBox,int supportingIfaces,int featureProperty) +void MockAccessibleNode::setProperties(std::string text,std::string pkg,std::string role,std::string id,std::string type,std::string style,std::string automationId, Rect boundingBox,int supportingIfaces,int featureProperty) { mText = text; mPkg = pkg; mRole = role; - mRes = res; + mId = id; + mAutomationId = automationId; mType = type; mStyle = style; mBoundingBox = boundingBox; @@ -58,12 +53,10 @@ void MockAccessibleNode::setProperties(std::string text,std::string pkg,std::str void MockAccessibleNode::refresh() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); } std::vector MockAccessibleNode::getActions() const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); std::vector ret{}; std::transform(mActionSet.begin(), mActionSet.end(), std::back_inserter(ret), [](auto action){ return action; @@ -73,20 +66,17 @@ std::vector MockAccessibleNode::getActions() const bool MockAccessibleNode::doAction(std::string action) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); if (mActionSet.find(action) != mActionSet.end()) return true; return false; } void MockAccessibleNode::setValue(std::string text) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); mText = text; } void MockAccessibleNode::setFeatureProperty(int type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); switch(type) { case 1: setFeatureProperty(NodeFeatureProperties::CHECKED, true); @@ -133,6 +123,15 @@ void MockAccessibleNode::addChild(std::shared_ptr child) mChildrenList.push_back(child); } +std::shared_ptr MockAccessibleNode::addChild(std::string text, std::string pkg, std::string role, std::string res, std::string type, std::string style, std::string automationId, Rect geometry, int ifaces, int properties) +{ + std::unique_lock lock(mLock); + + auto node = std::make_shared(shared_from_this(), text, pkg, role, res, type, style, automationId, geometry, ifaces, properties); + this->addChild(node); + return node; +} + void MockAccessibleNode::clearChildren(void) { mChildrenList.clear(); diff --git a/libaurum/src/Impl/Accessibility/MockAccessibleWatcher.cc b/libaurum/src/Impl/Accessibility/MockAccessibleWatcher.cc index 6c4b9e0..68f7f54 100644 --- a/libaurum/src/Impl/Accessibility/MockAccessibleWatcher.cc +++ b/libaurum/src/Impl/Accessibility/MockAccessibleWatcher.cc @@ -1,68 +1,40 @@ #include "MockAccessibleWatcher.h" #include "MockAccessibleWindow.h" +#include "MockAccessibleApplication.h" #include "MockAccessibleNode.h" -#include - MockAccessibleWatcher::MockAccessibleWatcher() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - - /* - Root - Application - Window - Node - Node - Node - Node - Node - Node - Node - Node - Node - Node - Node - Node - Window - Node - Node - Application - Window - Application - Window - Application - Window - Application - Window - */ } MockAccessibleWatcher::~MockAccessibleWatcher() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); } int MockAccessibleWatcher::getApplicationCount(void) const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return -1; + return mApplicationList.size(); } std::shared_ptr MockAccessibleWatcher::getApplicationAt(int index) const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mApplicationList.at(index); } std::vector> MockAccessibleWatcher::getApplications(void) const { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return mApplicationList; } void MockAccessibleWatcher::addApplication(std::shared_ptr application) { mApplicationList.push_back(application); - +} + +std::shared_ptr MockAccessibleWatcher::addApplication(std::string pkgName, Rect geometry, int ifaces, int properties) +{ + std::shared_ptr appNode = std::make_shared(nullptr, pkgName, pkgName, "application", "", "Elm_Win", "default", "", geometry, ifaces, properties); + std::shared_ptr app = std::make_shared(appNode); + this->addApplication(app); + return app; } \ No newline at end of file diff --git a/libaurum/src/Impl/Accessibility/MockAccessibleWindow.cc b/libaurum/src/Impl/Accessibility/MockAccessibleWindow.cc index 23ea498..73ed9c2 100644 --- a/libaurum/src/Impl/Accessibility/MockAccessibleWindow.cc +++ b/libaurum/src/Impl/Accessibility/MockAccessibleWindow.cc @@ -1,12 +1,19 @@ #include "MockAccessibleWindow.h" +#include "MockAccessibleApplication.h" +#include "MockAccessibleNode.h" -MockAccessibleWindow::MockAccessibleWindow(std::shared_ptr app, std::shared_ptr node) -: AccessibleWindow(app, node) +MockAccessibleWindow::MockAccessibleWindow(std::shared_ptr app, std::shared_ptr node) +: AccessibleWindow(app, node), mMockNode{node} { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); } MockAccessibleWindow::~MockAccessibleWindow() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); +} + +std::shared_ptr MockAccessibleWindow::addNode(std::string text, std::string pkg, std::string role, std::string res, std::string type, std::string style, std::string automationId, Rect geometry, int ifaces, int properties) +{ + auto node = std::make_shared(mMockNode, text, pkg, role, res, type, style, automationId, geometry, ifaces, properties); + mMockNode->addChild(node); + return node; } \ No newline at end of file diff --git a/libaurum/src/Impl/MockDeviceImpl.cc b/libaurum/src/Impl/MockDeviceImpl.cc index 3fdf45b..743e3b7 100644 --- a/libaurum/src/Impl/MockDeviceImpl.cc +++ b/libaurum/src/Impl/MockDeviceImpl.cc @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -10,174 +11,224 @@ #include #include +#include + +#include +#include MockDeviceImpl::MockDeviceImpl() -:tStart{}, isTimerStarted{false}, mTouchSeq{} +:tStart{}, isTimerStarted{false}, mTouchRelease{}, mTouchDown{}, mKeyDevice{}, mWheelDevice{0} { - printf("mockdevice ctor\n");printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); + mTouchRelease.emplace(1, TouchData{0,0,0,0}); + mTouchRelease.emplace(2, TouchData{0,0,0,0}); } MockDeviceImpl::~MockDeviceImpl() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); } bool MockDeviceImpl::click(const int x, const int y) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + return click(x, y, INTV_CLICK); } bool MockDeviceImpl::click(const int x, const int y, const unsigned int intv) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + int seq = touchDown(x, y); + if (seq < 0) return false; + std::this_thread::sleep_for(std::chrono::milliseconds{intv}); + return touchUp(x, y, seq); } bool MockDeviceImpl::drag(const int sx, const int sy, const int ex, const int ey, const int steps, const int durationMs) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + int i, j; + int _durationUs, _steps, _stepUs; + int dur; + int consumptionUs; + + if (steps <= 0) _steps = 1; + else _steps = steps; + + if (durationMs < MINIMUM_DURATION_DRAG) _durationUs = INTV_MINIMUM_DRAG_MS * MSEC_PER_SEC; + else _durationUs = durationMs * MSEC_PER_SEC; + + _stepUs = _durationUs / (_steps +1); + + if (_stepUs < (INTV_MINIMUM_DRAG_MS * MSEC_PER_SEC)) { + _steps = (int)(_durationUs / (INTV_MINIMUM_DRAG_MS * MSEC_PER_SEC)) - 1; + _stepUs = (INTV_MINIMUM_DRAG_MS * MSEC_PER_SEC); + } + startTimer(); + int seq = touchDown(sx, sy); + if (seq < 0) return false; + consumptionUs = stopTimer(); + + for ( int s = 1; s <= _steps + 1; s++) { + usleep((_stepUs - consumptionUs)>INTV_MINIMUM_USLEEP?(_stepUs - consumptionUs):INTV_MINIMUM_USLEEP); + startTimer(); + touchMove(sx + (ex - sx) * s / (steps + 1), sy + (ey - sy) * s / (steps + 1), seq); + consumptionUs = stopTimer(); + } + usleep((_stepUs - consumptionUs)>INTV_MINIMUM_USLEEP?(_stepUs - consumptionUs):INTV_MINIMUM_USLEEP); + touchMove(ex, ey, seq); + touchUp(ex, ey, seq); + + return true; } int MockDeviceImpl::touchDown(const int x, const int y) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return -1; + if (mTouchRelease.size() <= 0) return -1; + int seq = mTouchRelease.begin()->first; + mTouchDown[seq] = TouchData{x, y, timeStamp(), -1}; + mTouchRelease.erase(seq); + return seq; } bool MockDeviceImpl::touchMove(const int x, const int y, const int seq) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + if (mTouchDown.count(seq) <= 0) return false; + mTouchDown[seq] = TouchData{x, y, mTouchDown[seq].stamp1, timeStamp()}; + return true; } bool MockDeviceImpl::touchUp(const int x, const int y, const int seq) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; - + if (mTouchDown.count(seq) <= 0) return false; + mTouchRelease[seq] = TouchData{x, y, mTouchDown[seq].stamp1, timeStamp()}; + mTouchDown.erase(seq); + return true; } bool MockDeviceImpl::wheelUp(int amount, const int durationMs) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + for (int i = 0; i < amount; i++){ + mWheelDevice++; + usleep(durationMs*MSEC_PER_SEC/amount); + } + return true; } bool MockDeviceImpl::wheelDown(int amount, const int durationMs) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + for (int i = 0; i < amount; i++){ + mWheelDevice--; + usleep(durationMs*MSEC_PER_SEC/(double)amount); + } + + return true; } bool MockDeviceImpl::pressBack(KeyRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + mKeyDevice.push_back(std::tuple(MockKeyType::BACK, type, "")); + return true; } bool MockDeviceImpl::pressHome(KeyRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; + mKeyDevice.push_back(std::tuple(MockKeyType::HOME, type, "")); + return true; } bool MockDeviceImpl::pressMenu(KeyRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; - + mKeyDevice.push_back(std::tuple(MockKeyType::MENU, type, "")); + return true; } bool MockDeviceImpl::pressVolUp(KeyRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; - + mKeyDevice.push_back(std::tuple(MockKeyType::VOLUP, type, "")); + return true; } bool MockDeviceImpl::pressVolDown(KeyRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; - + mKeyDevice.push_back(std::tuple(MockKeyType::VOLDOWN, type, "")); + return true; } bool MockDeviceImpl::pressPower(KeyRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; - + mKeyDevice.push_back(std::tuple(MockKeyType::POWER, type, "")); + return true; } bool MockDeviceImpl::pressKeyCode(std::string keycode, KeyRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; - + mKeyDevice.push_back(std::tuple(MockKeyType::KEY, type, keycode)); + return true; } bool MockDeviceImpl::takeScreenshot(std::string path, float scale, int quality) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return false; - + return true; } long long MockDeviceImpl::getSystemTime(TimeRequestType type) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return -1; + struct timespec t; + + if (type == TimeRequestType::MONOTONIC) { + clock_gettime(CLOCK_MONOTONIC, &t); + } else if (type == TimeRequestType::WALLCLOCK) { + clock_gettime(CLOCK_REALTIME, &t); + } + + return (long long)t.tv_sec * 1000L + (long long)(t.tv_nsec / 1000000); } bool MockDeviceImpl::strokeKeyCode(std::string keycode, unsigned int intv) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return false; - } bool MockDeviceImpl::pressKeyCode(std::string keycode) { - - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return false; - } bool MockDeviceImpl::releaseKeyCode(std::string keycode) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return false; - } int MockDeviceImpl::grabTouchSeqNumber() { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return 0; } bool MockDeviceImpl::releaseTouchSeqNumber(int seq) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); return false; - } void MockDeviceImpl::startTimer(void) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); + isTimerStarted = true; + clock_gettime(CLOCK_MONOTONIC, &tStart); } int MockDeviceImpl::stopTimer(void) { - printf("%s:%d / %s\n",__FILE__, __LINE__, __PRETTY_FUNCTION__); - return 0; + struct timespec tEnd; + if (!isTimerStarted) return 0; + isTimerStarted = false; + clock_gettime(CLOCK_MONOTONIC, &tEnd); + return ((tEnd.tv_sec + tEnd.tv_nsec/1000000000.0) - (tStart.tv_sec + tStart.tv_nsec/1000000000.0)) * 1000000; +} + +long long MockDeviceImpl::timeStamp(void) +{ + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + long long rtn = (t.tv_sec + t.tv_nsec/1000000000.0) * 1000000; + return rtn; } \ No newline at end of file diff --git a/libaurum/src/PartialMatch.cc b/libaurum/src/PartialMatch.cc index 5edc6f2..942bc62 100644 --- a/libaurum/src/PartialMatch.cc +++ b/libaurum/src/PartialMatch.cc @@ -6,11 +6,20 @@ #include -bool PartialMatch::checkCriteria(const std::string *textA, const std::string textB) +bool PartialMatch::checkCriteria(const std::string *textA, const std::string textB, const bool *match) { - if (!textA) return false; + if (!textA || !match) return false; std::regex re(*textA); - return !std::regex_match(textB, re); + bool rst = !(!!std::regex_match(textB, re) == (*match)); + + LOG_F(INFO, "WKWK# %d %s %s=> %d\n", *match, textA->c_str(), textB.c_str(), rst); + return rst; +} + +bool PartialMatch::checkCriteria(const std::string *textA, const std::string textB) +{ + bool match = true; + return checkCriteria(textA, textB, &match); } bool PartialMatch::checkCriteria(const bool *boolA, const bool boolB) @@ -23,26 +32,26 @@ void PartialMatch::debugPrint() { if (mSelector->mPkg) LOG_F(INFO, "selector->pkg :%s", mSelector->mPkg->c_str()); - if (mSelector->mRes) - LOG_F(INFO, "selector->pkg :%s", mSelector->mRes->c_str()); + if (mSelector->mId) + LOG_F(INFO, "selector->id :%s", mSelector->mId->c_str()); if (mSelector->mText) - LOG_F(INFO, "selector->pkg :%s", mSelector->mText->c_str()); + LOG_F(INFO, "selector->text :%s", mSelector->mText->c_str()); if (mSelector->mType) - LOG_F(INFO, "selector->pkg :%s", mSelector->mType->c_str()); + LOG_F(INFO, "selector->type :%s", mSelector->mType->c_str()); if (mSelector->mStyle) - LOG_F(INFO, "selector->pkg :%s", mSelector->mStyle->c_str()); + LOG_F(INFO, "selector->style :%s", mSelector->mStyle->c_str()); } bool PartialMatch::checkCriteria(const std::shared_ptr selector, const std::shared_ptr node) { - if(checkCriteria(selector->mPkg.get(), node->getPkg())) return false; - if(checkCriteria(selector->mRes.get(), node->getRes())) return false; - if(checkCriteria(selector->mText.get(), node->getText())) return false; - if(checkCriteria(selector->mType.get(), node->getType())) return false; - if(checkCriteria(selector->mStyle.get(), node->getStyle())) return false; - if(checkCriteria(selector->mStyle.get(), node->getStyle())) return false; - + if(checkCriteria(selector->mText.get(), node->getText(), selector->mMatchText.get())) return false; + if(checkCriteria(selector->mId.get(), node->getId(), selector->mMatchId.get())) return false; + if(checkCriteria(selector->mAutomationId.get(), node->getAutomationId(), selector->mMatchAutomationId.get())) return false; + if(checkCriteria(selector->mType.get(), node->getType(), selector->mMatchType.get())) return false; + if(checkCriteria(selector->mStyle.get(), node->getStyle(), selector->mMatchStyle.get())) return false; + if(checkCriteria(selector->mPkg.get(), node->getPkg(), selector->mMatchPkg.get())) return false; + if(checkCriteria(selector->mRole.get(), node->getRole(), selector->mMatchRole.get())) return false; if(checkCriteria(selector->mIschecked.get(), node->isChecked())) return false; if(checkCriteria(selector->mIscheckable.get(), node->isCheckable())) return false; if(checkCriteria(selector->mIsclickable.get(), node->isClickable())) return false; @@ -53,6 +62,8 @@ bool PartialMatch::checkCriteria(const std::shared_ptr selector, if(checkCriteria(selector->mIsselected.get(), node->isSelected())) return false; if(checkCriteria(selector->mIsshowing.get(), node->isShowing())) return false; if(checkCriteria(selector->mIsactive.get(), node->isActive())) return false; + if(checkCriteria(selector->mIsvisible.get(), node->isVisible())) return false; + if(checkCriteria(selector->mIsselectable.get(), node->isSelectable())) return false; return true; } diff --git a/libaurum/src/UiDevice.cc b/libaurum/src/UiDevice.cc index f694f28..05d8f04 100644 --- a/libaurum/src/UiDevice.cc +++ b/libaurum/src/UiDevice.cc @@ -15,6 +15,7 @@ #include #include +#include UiDevice::UiDevice() : UiDevice(nullptr) {} UiDevice::UiDevice(IDevice *impl) @@ -57,7 +58,7 @@ std::vector> UiDevice::getWindowRoot() const auto activeWindows = app->getActiveWindows(); std::transform(activeWindows.begin(), activeWindows.end(), std::back_inserter(ret), [&](std::shared_ptr window){ - return window->getNode(); + return window->getAccessibleNode(); } ); } @@ -85,6 +86,7 @@ std::shared_ptr UiDevice::findObject(const std::shared_ptr if (foundNode) return std::make_shared(getInstance(), selector, foundNode); } + LOG_F(INFO, "object not found"); return std::shared_ptr{nullptr}; } diff --git a/libaurum/src/UiObject.cc b/libaurum/src/UiObject.cc index 6b5b987..4b52680 100644 --- a/libaurum/src/UiObject.cc +++ b/libaurum/src/UiObject.cc @@ -135,14 +135,30 @@ std::vector> UiObject::getChildren() const return this->findObjects(Sel::depth(1)); } +std::shared_ptr UiObject::getDescendant() +{ + std::vector> nodeChildren{}; + + auto children = getChildren(); + for (auto &&child : children) { + nodeChildren.push_back(child->getDescendant()); + } + return std::make_shared(shared_from_this(), nodeChildren); +} + std::string UiObject::getApplicationPackage() const { return getAccessibleNode()->getPkg(); } -std::string UiObject::getResourceName() const +std::string UiObject::getId() const +{ + return getAccessibleNode()->getId(); +} + +std::string UiObject::getAutomationId() const { - return getAccessibleNode()->getRes(); + return getAccessibleNode()->getAutomationId(); } std::string UiObject::getElementType() const diff --git a/libaurum/src/UiSelector.cc b/libaurum/src/UiSelector.cc index 886c729..663c24d 100644 --- a/libaurum/src/UiSelector.cc +++ b/libaurum/src/UiSelector.cc @@ -1,8 +1,16 @@ #include "UiSelector.h" #include + + + UiSelector::UiSelector() - : mChild{} +: mId{}, mAutomationId{}, mRole{}, mText{}, mPkg{}, mType{}, mStyle{}, + mMatchId{}, mMatchAutomationId{}, mMatchRole{}, mMatchText{}, mMatchPkg{}, mMatchType{}, mMatchStyle{}, + mMinDepth{}, mMaxDepth{}, mIschecked{}, mIscheckable{}, mIsclickable{}, + mIsenabled{}, mIsfocused{}, mIsfocusable{}, mIsscrollable{}, mIsselected{}, + mIsshowing{}, mIsactive{}, mIsvisible{}, mIsselectable{}, + mChild{}, mParent{} { } /* @@ -18,39 +26,53 @@ UiSelector& UiSelector::operator= (const UiSelector& src) return *this; } */ -UiSelector *UiSelector::id(std::string text) + +UiSelector *UiSelector::text(std::string text, bool match) { - this->mId = std::make_unique(text); + this->mText = std::make_unique(text); + this->mMatchText = std::make_unique(match); return this; } -UiSelector *UiSelector::text(std::string text) +UiSelector *UiSelector::pkg(std::string text, bool match) { - this->mText = std::make_unique(text); + this->mPkg = std::make_unique(text); + this->mMatchPkg = std::make_unique(match); return this; } -UiSelector *UiSelector::pkg(std::string text) +UiSelector *UiSelector::id(std::string text, bool match) { - this->mPkg = std::make_unique(text); + this->mId = std::make_unique(text); + this->mMatchId = std::make_unique(match); return this; } -UiSelector *UiSelector::res(std::string text) +UiSelector *UiSelector::automationid(std::string text, bool match) { - this->mRes = std::make_unique(text); + this->mAutomationId = std::make_unique(text); + this->mMatchAutomationId = std::make_unique(match); return this; } -UiSelector *UiSelector::type(std::string text) +UiSelector *UiSelector::role(std::string text, bool match) +{ + this->mRole = std::make_unique(text); + this->mMatchRole = std::make_unique(match); + return this; +} + +UiSelector *UiSelector::type(std::string text, bool match) { this->mType = std::make_unique(text); + this->mMatchType = std::make_unique(match); return this; } -UiSelector *UiSelector::style(std::string text) +UiSelector *UiSelector::style(std::string text, bool match) { this->mStyle = std::make_unique(text); + this->mMatchStyle = std::make_unique(match); return this; } @@ -140,8 +162,26 @@ UiSelector *UiSelector::isActive(bool cond) return this; } +UiSelector *UiSelector::isVisible(bool cond) +{ + this->mIsvisible = std::make_unique(cond); + return this; +} + +UiSelector *UiSelector::isSelectable(bool cond) +{ + this->mIsselectable = std::make_unique(cond); + return this; +} + UiSelector *UiSelector::hasChild(std::shared_ptr child) { mChild.push_back(child); return this; } + +UiSelector *UiSelector::fromParent(std::shared_ptr parent) +{ + mParent = parent; + return this; +} \ No newline at end of file diff --git a/org.tizen.aurum-bootstrap/src/Commands/FindElementCommand.cc b/org.tizen.aurum-bootstrap/src/Commands/FindElementCommand.cc index c7935e8..9056538 100644 --- a/org.tizen.aurum-bootstrap/src/Commands/FindElementCommand.cc +++ b/org.tizen.aurum-bootstrap/src/Commands/FindElementCommand.cc @@ -69,7 +69,7 @@ std::vector> FindElementCommand::getSelectors(void) UiObject* obj = found.get(); std::string key = mObjMap->addElement(std::move(found)); LOG_F(INFO, "found object : %s key:%s", - obj->getResourceName().c_str(), key.c_str()); + obj->getAutomationId().c_str(), key.c_str()); ::aurum::Element* elm = mResponse->add_elements(); elm->set_elementid(key); } diff --git a/protocol/examples/python/testInternal.py b/protocol/examples/python/testInternal.py index 3ad24c3..4d5548e 100644 --- a/protocol/examples/python/testInternal.py +++ b/protocol/examples/python/testInternal.py @@ -26,7 +26,7 @@ global img def traverse(node, canvas, depth): print('traverse', depth) - print('size:',node.geometry) + print('size:',node.geometry, node) #//canvas.pack() rect = canvas.create_rectangle(node.geometry.x, node.geometry.y, node.geometry.x+node.geometry.width, node.geometry.y+node.geometry.height, outline='red') diff --git a/tests/ua_test.cpp b/tests/ua_test.cpp index ad422cf..7209d1b 100644 --- a/tests/ua_test.cpp +++ b/tests/ua_test.cpp @@ -73,13 +73,13 @@ TEST_F(UaTest, FindElement) MockAccessibleWatcher *mockWatcher = dynamic_cast(const_cast(watcher)); ASSERT_NE(mockWatcher, nullptr); - std::shared_ptr appNode = std::make_shared(nullptr, "text", "pkg", "application", "res","type","style", Rect{0,0,100,200}, 0, 0); + std::shared_ptr appNode = std::make_shared(nullptr, "text", "pkg", "application", "res","type","style", "id1", Rect{0,0,100,200}, 0, 0); ASSERT_NE(appNode, nullptr); std::shared_ptr app = std::make_shared(appNode); ASSERT_NE(app, nullptr); mockWatcher->addApplication(app); - std::shared_ptr winNode = std::make_shared(nullptr, "text", "pkg", "window", "res","type","style", Rect{0,0,100,200}, 0, 0); + std::shared_ptr winNode = std::make_shared(nullptr, "text", "pkg", "window", "res","type","style", "id1",Rect{0,0,100,200}, 0, 0); ASSERT_NE(winNode, nullptr); std::shared_ptr win = std::make_shared(app, winNode); @@ -90,11 +90,11 @@ TEST_F(UaTest, FindElement) winNode->setFeatureProperty(10); app->addWindow(win); - std::shared_ptr node = std::make_shared(nullptr, "test", "pkg", "TeSt1234!@#$", "res","type","style", Rect{0,0,100,200}, 0, 0); + std::shared_ptr node = std::make_shared(nullptr, "test", "pkg", "TeSt1234!@#$", "res","type","style", "id1",Rect{0,0,100,200}, 0, 0); ASSERT_NE(node, nullptr); winNode->addChild(node); - node = std::make_shared(nullptr, "test", "pkg", "TeSt1234!@#$", "res","type","style", Rect{0,0,100,200}, 0, 0); + node = std::make_shared(nullptr, "test", "pkg", "TeSt1234!@#$", "res","type","style", "id1",Rect{0,0,100,200}, 0, 0); ASSERT_NE(node, nullptr); winNode->addChild(node); -- 2.7.4