Initialize and deinitialize input generator and gestor of the efl_util in every testcase.
for this, wrapping efl_util API with class and create the class on each testcase.
and, refactor some codes.
NOTE:: generation gesture functions that tap, edge swipe and edge drag gesture are still in e_test_event because of it uses timer.
Change-Id: I4a4164a12f8242d7ba543999fa60545bb8d0d9fe
e_test_win.h \
e_test_win.cpp \
e_test_util.h \
+e_test_efl_util.h \
+e_test_efl_util.cpp \
${tc_sources}
MAINTAINERCLEANFILES = \
--- /dev/null
+#include "e_test_efl_util.h"
+
+static const char*
+printErrorCode(int ret)
+{
+ switch(ret)
+ {
+ case EFL_UTIL_ERROR_NONE : return "Successful";
+ case EFL_UTIL_ERROR_INVALID_PARAMETER : return "Invalid parameter";
+ case EFL_UTIL_ERROR_OUT_OF_MEMORY : return "Out of memory";
+ case EFL_UTIL_ERROR_PERMISSION_DENIED : return "Permission denied";
+ case EFL_UTIL_ERROR_NO_SUCH_DEVICE : return "platform No such device or address";
+ case EFL_UTIL_ERROR_INVALID_OPERATION : return "platform Function not implemented";
+ case EFL_UTIL_ERROR_NOT_SUPPORTED : return "platform Not supported";
+ case EFL_UTIL_ERROR_NOT_SUPPORTED_WINDOW_TYPE : return "Window type not supported";
+ case EFL_UTIL_ERROR_SCREENSHOT_INIT_FAIL : return "platform Screenshot initialization fail";
+ case EFL_UTIL_ERROR_SCREENSHOT_EXECUTION_FAIL : return "platform Screenshot execution fail";
+ case EFL_UTIL_ERROR_NO_RESOURCE_AVAILABLE : return "Resource is not available";
+ default : return "CANNOT PRINT";
+ }
+}
+
+Eina_Bool
+etInputGenHandler::generateMouseDown(int x, int y)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_touch(handler,
+ 0,
+ EFL_UTIL_INPUT_TOUCH_BEGIN,
+ x, y);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate mouse down, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etInputGenHandler::generateMouseMove(int x, int y)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_touch(handler,
+ 0,
+ EFL_UTIL_INPUT_TOUCH_UPDATE,
+ x, y);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate mouse move, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etInputGenHandler::generateMouseUp(int x, int y)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_touch(handler,
+ 0,
+ EFL_UTIL_INPUT_TOUCH_END,
+ x, y);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate mouse up, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etInputGenHandler::generateKeyPress(const char *keyname)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_key(handler,
+ keyname,
+ 1);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate key press, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etInputGenHandler::generateKeyRelease(const char *keyname)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_key(handler,
+ keyname,
+ 0);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate key release, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etInputGenHandler::generateKeyEvent(const char *keyname, double delay)
+{
+ Eina_Bool res = EINA_FALSE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ res = generateKeyPress(keyname);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ res = generateKeyRelease(keyname);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
+
+ return res;
+}
+
+Eina_Bool
+etInputGenHandler::generateTouchDown(int idx, int x, int y)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_touch(handler,
+ idx,
+ EFL_UTIL_INPUT_TOUCH_BEGIN,
+ x, y);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate touch down, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etInputGenHandler::generateTouchMove(int idx, int x, int y)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_touch(handler,
+ idx,
+ EFL_UTIL_INPUT_TOUCH_UPDATE,
+ x, y);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate touch move, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool
+etInputGenHandler::generateTouchUp(int idx, int x, int y)
+{
+ // Using efl_util_input_generate instead of generate event by eldbus
+ int ret = EFL_UTIL_ERROR_NONE;
+
+ if (handler == NULL)
+ return EINA_FALSE;
+
+ ret = efl_util_input_generate_touch(handler,
+ idx,
+ EFL_UTIL_INPUT_TOUCH_END,
+ x, y);
+ if (ret != EFL_UTIL_ERROR_NONE)
+ {
+ printf("failed to generate touch up, ret: %d(%s)\n", ret, printErrorCode(ret));
+ return EINA_FALSE;
+ }
+
+ return EINA_TRUE;
+}
+
+#ifndef DISABLE_GESTURE_TESTS
+efl_util_gesture_data
+etGestureHandler::createTapData(unsigned int fingers, unsigned int repeats)
+{
+ if (handler == nullptr)
+ return nullptr;
+
+ return efl_util_gesture_tap_new(handler, fingers, repeats);
+}
+
+int
+etGestureHandler::freeTapData(efl_util_gesture_data data)
+{
+ if (handler == nullptr)
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ return efl_util_gesture_tap_free(handler, data);
+}
+
+efl_util_gesture_data
+etGestureHandler::createEdgeSwipeData(unsigned int fingers, efl_util_gesture_edge_e edge)
+{
+ if (handler == nullptr)
+ return nullptr;
+
+ return efl_util_gesture_edge_swipe_new(handler, fingers, edge);
+}
+
+int
+etGestureHandler::freeEdgeSwipeData(efl_util_gesture_data data)
+{
+ if (handler == nullptr)
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ return efl_util_gesture_edge_swipe_free(handler, data);
+}
+
+efl_util_gesture_data
+etGestureHandler::createEdgeDragData(unsigned int fingers, efl_util_gesture_edge_e edge)
+{
+ if (handler == nullptr)
+ return nullptr;
+
+ return efl_util_gesture_edge_drag_new(handler, fingers, edge);
+}
+
+int
+etGestureHandler::freeEdgeDragData(efl_util_gesture_data data)
+{
+ if (handler == nullptr)
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ return efl_util_gesture_edge_drag_free(handler, data);
+}
+
+int
+etGestureHandler::grabGesture(efl_util_gesture_data data)
+{
+ if (handler == nullptr)
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ return efl_util_gesture_grab(handler, data);
+}
+
+int
+etGestureHandler::ungrabGesture(efl_util_gesture_data data)
+{
+ if (handler == nullptr)
+ return EFL_UTIL_ERROR_INVALID_PARAMETER;
+
+ return efl_util_gesture_grab(handler, data);
+}
+#endif
\ No newline at end of file
--- /dev/null
+#ifndef __ET_TESTCASE_EFL_UTIL__
+#define __ET_TESTCASE_EFL_UTIL__
+
+#include <memory>
+
+#include <efl_util.h>
+
+class etInputGenHandler
+{
+ public :
+ etInputGenHandler() = delete;
+ etInputGenHandler(efl_util_input_device_type_e type) :
+ handler(nullptr)
+ {
+ handler = efl_util_input_initialize_generator_with_name(type, NULL);
+
+ if (handler == nullptr)
+ printf("failed to init input generator\n");
+ }
+ ~etInputGenHandler()
+ {
+ efl_util_input_deinitialize_generator(handler);
+ handler = nullptr;
+ }
+
+ efl_util_inputgen_h getHandler() { return handler; }
+
+ Eina_Bool generateMouseDown(int x, int y);
+ Eina_Bool generateMouseMove(int x, int y);
+ Eina_Bool generateMouseUp(int x, int y);
+ Eina_Bool generateKeyPress(const char *key);
+ Eina_Bool generateKeyRelease(const char *key);
+ Eina_Bool generateKeyEvent(const char *keyname, double delay);
+ Eina_Bool generateTouchDown(int idx, int x, int y);
+ Eina_Bool generateTouchMove(int idx, int x, int y);
+ Eina_Bool generateTouchUp(int idx, int x, int y);
+
+ private :
+ efl_util_inputgen_h handler;
+};
+
+typedef std::shared_ptr<etInputGenHandler> InputGenHandler;
+
+#ifndef DISABLE_GESTURE_TESTS
+class etGestureHandler
+{
+ public :
+ etGestureHandler() :
+ handler(nullptr)
+ {
+ handler = efl_util_gesture_initialize();
+
+ if (handler == nullptr)
+ printf("failed to init gesture\n");
+ }
+ ~etGestureHandler()
+ {
+ efl_util_gesture_deinitialize(handler);
+ handler = nullptr;
+ }
+
+ efl_util_gesture_h getHandler() { return handler; }
+
+ efl_util_gesture_data createTapData(unsigned int fingers, unsigned int repeats);
+ int freeTapData(efl_util_gesture_data data);
+ efl_util_gesture_data createEdgeSwipeData(unsigned int fingers, efl_util_gesture_edge_e edge);
+ int freeEdgeSwipeData(efl_util_gesture_data data);
+ efl_util_gesture_data createEdgeDragData(unsigned int fingers, efl_util_gesture_edge_e edge);
+ int freeEdgeDragData(efl_util_gesture_data data);
+ int grabGesture(efl_util_gesture_data data);
+ int ungrabGesture(efl_util_gesture_data data);
+
+ private :
+ efl_util_gesture_h handler;
+};
+typedef std::shared_ptr<etGestureHandler> GestureHandler;
+#endif
+
+#endif // end of __ET_TESTCASE_EFL_UTIL__
\ No newline at end of file
res = resetRegisterWin();
EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
- // init input generator
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN | EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
- EINA_SAFETY_ON_NULL_RETURN_VAL(inputGenerator, EINA_FALSE);
-
- // init gesture handler
- #ifndef DISABLE_GESTURE_TESTS
- gestureHandler = efl_util_gesture_initialize();
- EINA_SAFETY_ON_NULL_RETURN_VAL(gestureHandler, EINA_FALSE);
- #endif
-
// add signal handlers
res = addSignalHandlers();
EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
}
delSignalHandlers();
+ delGestureSignalHandlers();
// deinit tizen_extension protocol
if (tzPolicy)
eldbus_object_unref(dbus.ds_obj);
eldbus_connection_unref(dbus.conn);
eldbus_shutdown();
-
- // deinit input generator
- efl_util_input_deinitialize_generator(inputGenerator);
-
- // deinit gesture handler
-#ifndef DISABLE_GESTURE_TESTS
- efl_util_gesture_deinitialize(gestureHandler);
-#endif
}
Eina_Bool
return EINA_TRUE;
}
-Eina_Bool
-etRunner::generateMouseDown(int x, int y)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
- work();
- }
-
- ret = efl_util_input_generate_touch(inputGenerator,
- 0,
- EFL_UTIL_INPUT_TOUCH_BEGIN,
- x, y);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool
-etRunner::generateMouseMove(int x, int y)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
- work();
- }
-
- ret = efl_util_input_generate_touch(inputGenerator,
- 0,
- EFL_UTIL_INPUT_TOUCH_UPDATE,
- x, y);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool
-etRunner::generateMouseUp(int x, int y)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
- work();
- }
-
- ret = efl_util_input_generate_touch(inputGenerator,
- 0,
- EFL_UTIL_INPUT_TOUCH_END,
- x, y);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool
-etRunner::generateKeyPress(const char *keyname)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
- work();
- }
-
- ret = efl_util_input_generate_key(inputGenerator,
- keyname,
- 1);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool
-etRunner::generateKeyRelease(const char *keyname)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD, NULL);
- work();
- }
-
- ret = efl_util_input_generate_key(inputGenerator,
- keyname,
- 0);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool
-etRunner::generateKeyEvent(const char *keyname, double delay)
-{
- Eina_Bool res = EINA_FALSE;
-
- res = etRunner::get().generateKeyPress(keyname);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
-
- res = etRunner::get().generateKeyRelease(keyname);
- EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE);
-
- return res;
-}
-
-Eina_Bool
-etRunner::generateTouchDown(int idx, int x, int y)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
- work();
- }
-
- ret = efl_util_input_generate_touch(inputGenerator,
- idx,
- EFL_UTIL_INPUT_TOUCH_BEGIN,
- x, y);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool
-etRunner::generateTouchMove(int idx, int x, int y)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
- work();
- }
-
- ret = efl_util_input_generate_touch(inputGenerator,
- idx,
- EFL_UTIL_INPUT_TOUCH_UPDATE,
- x, y);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-Eina_Bool
-etRunner::generateTouchUp(int idx, int x, int y)
-{
- // Using efl_util_input_generate instead of generate event by eldbus
- int ret = EFL_UTIL_ERROR_NONE;
-
- if (inputGenerator == NULL)
- {
- inputGenerator = efl_util_input_initialize_generator_with_name(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN, NULL);
- work();
- }
-
- ret = efl_util_input_generate_touch(inputGenerator,
- idx,
- EFL_UTIL_INPUT_TOUCH_END,
- x, y);
- if (ret != EFL_UTIL_ERROR_NONE)
- {
- efl_util_input_deinitialize_generator(inputGenerator);
- inputGenerator = NULL;
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
Eina_Bool
etRunner::setSplashLaunch(const char *path, int type)
{
EINA_SAFETY_ON_NULL_GOTO(eh, err);
ev.eh_list = eina_list_append(ev.eh_list, eh);
+ ev.key.ecore_state = EINA_FALSE;
+
+ return EINA_TRUE;
+
+err:
+ printf("failed to init handlers\n");
+ delSignalHandlers();
+ return EINA_FALSE;
+}
+
+Eina_Bool
+etRunner::addGestureSignalHandlers()
+{
+ Ecore_Event_Handler *eh = NULL;
+
#ifndef DISABLE_GESTURE_TESTS
+ if ((EFL_UTIL_EVENT_GESTURE_TAP == 0) ||
+ (EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE == 0) ||
+ (EFL_UTIL_EVENT_GESTURE_EDGE_DRAG == 0))
+ goto err;
+
+ if (ev.last_gesture_tap_ev != EFL_UTIL_EVENT_GESTURE_TAP)
+ delGestureSignalHandlers();
+
eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_TAP, _cb_gesture_tap, this);
EINA_SAFETY_ON_NULL_GOTO(eh, err);
- ev.eh_list = eina_list_append(ev.eh_list, eh);
+ ev.eh_gesture_list = eina_list_append(ev.eh_gesture_list, eh);
eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_SWIPE, _cb_gesture_edge_swipe, this);
EINA_SAFETY_ON_NULL_GOTO(eh, err);
- ev.eh_list = eina_list_append(ev.eh_list, eh);
+ ev.eh_gesture_list = eina_list_append(ev.eh_gesture_list, eh);
eh = ecore_event_handler_add(EFL_UTIL_EVENT_GESTURE_EDGE_DRAG, _cb_gesture_edge_drag, this);
EINA_SAFETY_ON_NULL_GOTO(eh, err);
- ev.eh_list = eina_list_append(ev.eh_list, eh);
-#endif
+ ev.eh_gesture_list = eina_list_append(ev.eh_gesture_list, eh);
- ev.key.ecore_state = EINA_FALSE;
+ ev.last_gesture_tap_ev = EFL_UTIL_EVENT_GESTURE_TAP;
+#endif
return EINA_TRUE;
err:
- printf("failed to init handlers\n");
- delSignalHandlers();
+ printf("failed to init gesture handlers\n");
+ delGestureSignalHandlers();
return EINA_FALSE;
}
flushEventQueue();
}
+void
+etRunner::delGestureSignalHandlers()
+{
+ Ecore_Event_Handler *eh = NULL;
+
+ EINA_LIST_CAST_FREE(ev.eh_gesture_list, eh, Ecore_Event_Handler*)
+ {
+ ecore_event_handler_del(eh);
+ }
+
+ flushEventQueue();
+}
+
void
etRunner::work()
{
runner->ev.key.evas_state = EINA_TRUE;
}
}
+ evas_object_event_callback_del(runner->ev.elm_win, EVAS_CALLBACK_KEY_DOWN, _cb_evas_key_down);
}
static void
runner->insertEventQueue(runner->ev.native_win, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
}
}
+ evas_object_event_callback_del(runner->ev.elm_win, EVAS_CALLBACK_KEY_UP, _cb_evas_key_up);
}
/* callbacks - smart object */
static Eina_Bool
_cb_gesture_tap_delay_timer(void *data)
{
- etRunner *runner = (etRunner *)data;
+ etRunner *runner = &etRunner::get();
+ etInputGenHandler *inputgen_h = (etInputGenHandler *) data;
int i;
for (i = 0; i < runner->ev.gesture.tap.fingers; i++)
{
if (!runner->ev.gesture.tap.pressed)
{
- runner->generateTouchDown(i, 100 * (i + 1), 100 * (i + 1));
+ inputgen_h->generateTouchDown(i, 100 * (i + 1), 100 * (i + 1));
}
else
{
- runner->generateTouchUp(i, 100 * (i + 1), 100 * (i + 1));
+ inputgen_h->generateTouchUp(i, 100 * (i + 1), 100 * (i + 1));
}
}
{
runner->ev.gesture.timer = ecore_timer_add(0.11,
_cb_gesture_tap_delay_timer,
- runner);
+ inputgen_h);
}
return ECORE_CALLBACK_CANCEL;
}
Eina_Bool
-etRunner::generateTapGesture()
+etRunner::generateTapGesture(InputGenHandler handler)
{
+ addGestureSignalHandlers();
+
ev.gesture.tap.current_repeats = ev.gesture.tap.repeats;
ev.gesture.tap.pressed = EINA_FALSE;
ev.gesture.timer = ecore_timer_add(0.11,
_cb_gesture_tap_delay_timer,
- this);
-
+ handler.get());
return EINA_TRUE;
}
static Eina_Bool
_cb_gesture_edge_swipe_delay_timer(void *data)
{
- etRunner *runner = (etRunner *)data;
+ etRunner *runner = &etRunner::get();
+ etInputGenHandler *inputgen_h = (etInputGenHandler *) data;
int i, cnt, fingers, w, h;
efl_util_gesture_edge_e edge;
switch (edge)
{
case EFL_UTIL_GESTURE_EDGE_TOP:
- runner->generateTouchDown(i, 100 * (i + 1), 1);
+ inputgen_h->generateTouchDown(i, 100 * (i + 1), 1);
break;
case EFL_UTIL_GESTURE_EDGE_RIGHT:
- runner->generateTouchDown(i, w - 1, 100 * (i + 1));
+ inputgen_h->generateTouchDown(i, w - 1, 100 * (i + 1));
break;
case EFL_UTIL_GESTURE_EDGE_BOTTOM:
- runner->generateTouchDown(i, 100 * (i + 1), h - 1);
+ inputgen_h->generateTouchDown(i, 100 * (i + 1), h - 1);
break;
case EFL_UTIL_GESTURE_EDGE_LEFT:
- runner->generateTouchDown(i, 1, 100 * (i + 1));
+ inputgen_h->generateTouchDown(i, 1, 100 * (i + 1));
break;
default:
break;
switch (edge)
{
case EFL_UTIL_GESTURE_EDGE_TOP:
- runner->generateTouchMove(i, 100 * (i + 1), 40 * cnt * cnt);
+ inputgen_h->generateTouchMove(i, 100 * (i + 1), 40 * cnt * cnt);
break;
case EFL_UTIL_GESTURE_EDGE_RIGHT:
- runner->generateTouchMove(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
+ inputgen_h->generateTouchMove(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
break;
case EFL_UTIL_GESTURE_EDGE_BOTTOM:
- runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
+ inputgen_h->generateTouchMove(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
break;
case EFL_UTIL_GESTURE_EDGE_LEFT:
- runner->generateTouchMove(i, 40 * cnt * cnt, 100 * (i + 1));
+ inputgen_h->generateTouchMove(i, 40 * cnt * cnt, 100 * (i + 1));
break;
default:
break;
switch (edge)
{
case EFL_UTIL_GESTURE_EDGE_TOP:
- runner->generateTouchUp(i, 100 * (i + 1), 40 * cnt * cnt);
+ inputgen_h->generateTouchUp(i, 100 * (i + 1), 40 * cnt * cnt);
break;
case EFL_UTIL_GESTURE_EDGE_RIGHT:
- runner->generateTouchUp(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
+ inputgen_h->generateTouchUp(i, (w - 1) - (40 * cnt * cnt), 100 * (i + 1));
break;
case EFL_UTIL_GESTURE_EDGE_BOTTOM:
- runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
+ inputgen_h->generateTouchUp(i, 100 * (i + 1), (h - 1) - (40 * cnt * cnt));
break;
case EFL_UTIL_GESTURE_EDGE_LEFT:
- runner->generateTouchUp(i, 40 * cnt * cnt, 100 * (i + 1));
+ inputgen_h->generateTouchUp(i, 40 * cnt * cnt, 100 * (i + 1));
break;
default:
break;
runner->ev.gesture.timer = NULL;
runner->ev.gesture.timer = ecore_timer_add(0.11,
_cb_gesture_edge_swipe_delay_timer,
- runner);
+ inputgen_h);
return ECORE_CALLBACK_CANCEL;
}
Eina_Bool
-etRunner::generateEdgeSwipeGesture()
+etRunner::generateEdgeSwipeGesture(InputGenHandler handler)
{
ev.gesture.edge.touch_count = 0;
ev.gesture.edge.get_event = EINA_FALSE;
ev.gesture.timer = ecore_timer_add(0.11,
_cb_gesture_edge_swipe_delay_timer,
- this);
+ handler.get());
return EINA_TRUE;
}
static Eina_Bool
_cb_gesture_edge_drag_delay_timer(void *data)
{
- etRunner *runner = (etRunner *)data;
+ etRunner *runner = &etRunner::get();
+ etInputGenHandler *inputgen_h = (etInputGenHandler *)data;
+
int i, cnt, fingers, w, h;
efl_util_gesture_edge_e edge;
switch (edge)
{
case EFL_UTIL_GESTURE_EDGE_TOP:
- runner->generateTouchDown(i, 100 * (i + 1), 1);
+ inputgen_h->generateTouchDown(i, 100 * (i + 1), 1);
break;
case EFL_UTIL_GESTURE_EDGE_RIGHT:
- runner->generateTouchDown(i, w - 1, 100 * (i + 1));
+ inputgen_h->generateTouchDown(i, w - 1, 100 * (i + 1));
break;
case EFL_UTIL_GESTURE_EDGE_BOTTOM:
- runner->generateTouchDown(i, 100 * (i + 1), h - 1);
+ inputgen_h->generateTouchDown(i, 100 * (i + 1), h - 1);
break;
case EFL_UTIL_GESTURE_EDGE_LEFT:
- runner->generateTouchDown(i, 1, 100 * (i + 1));
+ inputgen_h->generateTouchDown(i, 1, 100 * (i + 1));
break;
default:
break;
switch (edge)
{
case EFL_UTIL_GESTURE_EDGE_TOP:
- runner->generateTouchMove(i, 100 * (i + 1), 50 * cnt);
+ inputgen_h->generateTouchMove(i, 100 * (i + 1), 50 * cnt);
break;
case EFL_UTIL_GESTURE_EDGE_RIGHT:
- runner->generateTouchMove(i, (w - 1) - (50 * cnt), 100 * (i + 1));
+ inputgen_h->generateTouchMove(i, (w - 1) - (50 * cnt), 100 * (i + 1));
break;
case EFL_UTIL_GESTURE_EDGE_BOTTOM:
- runner->generateTouchMove(i, 100 * (i + 1), (h - 1) - (50 * cnt));
+ inputgen_h->generateTouchMove(i, 100 * (i + 1), (h - 1) - (50 * cnt));
break;
case EFL_UTIL_GESTURE_EDGE_LEFT:
- runner->generateTouchMove(i, 50 * cnt, 100 * (i + 1));
+ inputgen_h->generateTouchMove(i, 50 * cnt, 100 * (i + 1));
break;
default:
break;
switch (edge)
{
case EFL_UTIL_GESTURE_EDGE_TOP:
- runner->generateTouchUp(i, 100 * (i + 1), 50 * cnt);
+ inputgen_h->generateTouchUp(i, 100 * (i + 1), 50 * cnt);
break;
case EFL_UTIL_GESTURE_EDGE_RIGHT:
- runner->generateTouchUp(i, (w - 1) - (50 * cnt), 100 * (i + 1));
+ inputgen_h->generateTouchUp(i, (w - 1) - (50 * cnt), 100 * (i + 1));
break;
case EFL_UTIL_GESTURE_EDGE_BOTTOM:
- runner->generateTouchUp(i, 100 * (i + 1), (h - 1) - (50 * cnt));
+ inputgen_h->generateTouchUp(i, 100 * (i + 1), (h - 1) - (50 * cnt));
break;
case EFL_UTIL_GESTURE_EDGE_LEFT:
- runner->generateTouchUp(i, 50 * cnt, 100 * (i + 1));
+ inputgen_h->generateTouchUp(i, 50 * cnt, 100 * (i + 1));
break;
default:
break;
runner->ev.gesture.timer = NULL;
runner->ev.gesture.timer = ecore_timer_add(0.11,
_cb_gesture_edge_drag_delay_timer,
- runner);
+ inputgen_h);
return ECORE_CALLBACK_CANCEL;
}
Eina_Bool
-etRunner::generateEdgeDragGesture()
+etRunner::generateEdgeDragGesture(InputGenHandler handler)
{
ev.gesture.edge.touch_count = 0;
ev.gesture.timer = ecore_timer_add(0.11,
_cb_gesture_edge_drag_delay_timer,
- this);
+ handler.get());
return EINA_TRUE;
}
#include "e_test_util.h"
#include "e_test_win.h"
+#include "e_test_efl_util.h"
class eventItem
{
Eina_List *sh_list; // Signal Handler list
Eina_List *eh_list; // Event Handler list
+ Eina_List *eh_gesture_list; // Event Handler of gesture list
+ int last_gesture_tap_ev;
std::list<std::shared_ptr<eventItem>> recv_queue;
std::list<std::shared_ptr<eventItem>>::iterator wait_event_index;
Eina_Bool feedMouseUp(int x, int y);
Eina_Bool feedKeyDown(const char *key);
Eina_Bool feedKeyUp(const char *key);
- Eina_Bool generateMouseDown(int x, int y);
- Eina_Bool generateMouseMove(int x, int y);
- Eina_Bool generateMouseUp(int x, int y);
- Eina_Bool generateKeyPress(const char *key);
- Eina_Bool generateKeyRelease(const char *key);
- Eina_Bool generateKeyEvent(const char *keyname, double delay);
- Eina_Bool generateTouchDown(int idx, int x, int y);
- Eina_Bool generateTouchMove(int idx, int x, int y);
- Eina_Bool generateTouchUp(int idx, int x, int y);
#ifndef DISABLE_GESTURE_TESTS
- Eina_Bool generateTapGesture();
- Eina_Bool generateEdgeSwipeGesture();
- Eina_Bool generateEdgeDragGesture();
+ Eina_Bool generateTapGesture(InputGenHandler handler);
+ Eina_Bool generateEdgeSwipeGesture(InputGenHandler handler);
+ Eina_Bool generateEdgeDragGesture(InputGenHandler handler);
#endif
Eina_Bool setSplashLaunch(const char *path, int type);
Eina_Bool setSplashOwner();
Eina_Bool isEventOccuredAfterCheckpoint(etWin *tw, E_TC_Event_Type ev_type);
void setEventCheckpoint();
Eina_Bool addSignalHandlers();
+ Eina_Bool addGestureSignalHandlers();
void delSignalHandlers();
+ void delGestureSignalHandlers();
void unwatchEventSignal();
Eldbus_Proxy *getDbusProxy() { return dbus.ds_proxy; }
Eldbus_Object *getDbusObject() { return dbus.ds_obj; }
int getLogDomain() { return logDomain; }
-#ifndef DISABLE_GESTURE_TESTS
- efl_util_gesture_h getGestureHandler() { return gestureHandler; }
-#endif
Eina_Bool verifyTC(std::string basetype, std::string tcname);
void parseTargetInfo(int argc, char **argv);
void watchEventSignal(Ecore_Window win, E_TC_Event_Type ev_type);
Eina_Bool isWatchingEventSignal(std::shared_ptr<eventItem> ei);
Eina_Bool isWatchingEventSignal(Ecore_Window win, E_TC_Event_Type ev_type);
- efl_util_inputgen_h inputGenerator = NULL;
-#ifndef DISABLE_GESTURE_TESTS
- efl_util_gesture_h gestureHandler = NULL;
-#endif
efl_util_screenshot_h screenshot = NULL;
};
#include "e_test_event.h"
#include "e_test_base.h"
+#include "e_test_efl_util.h"
class etTestFocus : public ::etTCBase
{
initTC(EINA_TRUE, EINA_TRUE);
// touch red win
- etRunner::get().generateMouseDown(50, 50);
- etRunner::get().generateMouseUp(50, 50);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ inputgen_h->generateMouseDown(50, 50);
+ inputgen_h->generateMouseUp(50, 50);
ASSERT_FOCUS_IN(tw_red);
// Expected focus res:
initTC(EINA_TRUE, EINA_TRUE);
// touch red win
- etRunner::get().generateMouseDown(50, 50);
- etRunner::get().generateMouseUp(50, 50);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ inputgen_h->generateMouseDown(50, 50);
+ inputgen_h->generateMouseUp(50, 50);
ASSERT_FOCUS_IN(tw_red);
// touch blue win
- etRunner::get().generateMouseDown(250, 250);
- etRunner::get().generateMouseUp(250, 250);
+ inputgen_h->generateMouseDown(250, 250);
+ inputgen_h->generateMouseUp(250, 250);
ASSERT_FOCUS_IN(tw_blue);
// Expected focus res:
initTC(EINA_TRUE, EINA_TRUE);
// touch green win
- etRunner::get().generateMouseDown(150, 150);
- etRunner::get().generateMouseUp(150, 150);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ inputgen_h->generateMouseDown(150, 150);
+ inputgen_h->generateMouseUp(150, 150);
ASSERT_FOCUS_IN(tw_green);
// Expected focus res:
etRunner::get().work(0.1); // waiting for adjust focus skip
// touch red win
- etRunner::get().generateMouseDown(50, 50);
- etRunner::get().generateMouseUp(50, 50);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ inputgen_h->generateMouseDown(50, 50);
+ inputgen_h->generateMouseUp(50, 50);
etRunner::get().work(0.1); // waiting for adjust focus skip
// Expected focus res:
+#include <Ecore_Wl2.h>
+
#include "e_test_event.h"
#include "e_test_base.h"
-#include <Ecore_Wl2.h>
+#include "e_test_efl_util.h"
class etTestInput : public ::etTCBase
{
ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_SHARED);
ASSERT_TRUE(ret);
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
ASSERT_NE(ev_result, nullptr);
ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_OVERRIDE_EXCLUSIVE);
ASSERT_TRUE(ret);
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
ASSERT_NE(ev_result, nullptr);
ret = ecore_wl2_window_keygrab_set(NULL, "XF86Menu", 0, 0, 0, ECORE_WL2_WINDOW_KEYGRAB_EXCLUSIVE);
ASSERT_TRUE(ret);
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_INPUT_ECORE_KEY);
ASSERT_NE(ev_result, nullptr);
ASSERT_EVENT(tw_shared, E_TC_EVENT_TYPE_STACK_LOWER);
ASSERT_TRUE(ret);
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
etRunner::get().ev.elm_win = NULL;
ASSERT_TRUE(ret);
ASSERT_EVENT(tw_orexcl, E_TC_EVENT_TYPE_STACK_LOWER);
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
etRunner::get().ev.elm_win = NULL;
ASSERT_EVENT(tw_excl, E_TC_EVENT_TYPE_STACK_LOWER);
ASSERT_TRUE(ret);
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
etRunner::get().ev.elm_win = NULL;
etRunner::get().ev.elm_win = tw_topposition->elm_win;
etRunner::get().ev.native_win = tw_topposition->native_win;
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
etRunner::get().ev.elm_win = NULL;
etRunner::get().ev.elm_win = tw_excl->elm_win;
etRunner::get().ev.native_win = tw_excl->native_win;
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ InputGenHandler inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_KEYBOARD);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_excl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
evas_object_key_ungrab(tw_excl->elm_win, "XF86Menu", 0, 0);
etRunner::get().ev.elm_win = tw_orexcl->elm_win;
etRunner::get().ev.native_win = tw_orexcl->native_win;
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_orexcl, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
evas_object_key_ungrab(tw_orexcl->elm_win, "XF86Menu", 0, 0);
etRunner::get().ev.elm_win = tw_topposition->elm_win;
etRunner::get().ev.native_win = tw_topposition->native_win;
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_topposition, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
evas_object_key_ungrab(tw_topposition->elm_win, "XF86Menu", 0, 0);
etRunner::get().ev.elm_win = tw_shared->elm_win;
etRunner::get().ev.native_win = tw_shared->native_win;
- etRunner::get().generateKeyEvent(key_name, 0.3);
+ inputgen_h->generateKeyEvent(key_name, 0.3);
ASSERT_EVENT(tw_shared, E_TC_EVENT_TYPE_INPUT_EVAS_KEY);
evas_object_key_ungrab(tw_shared->elm_win, "XF86Menu", 0, 0);
TEST_F(etTestInput, gesture_tap22)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
+ auto inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ GestureHandler gesture_h = std::make_shared<etGestureHandler>();
efl_util_gesture_data tap_d;
- tap_d = efl_util_gesture_tap_new(gesture_h, 2, 2);
+ tap_d = gesture_h->createTapData(2, 2);
ASSERT_TRUE(tap_d != NULL) << "failed to generate tap grab data";
- ret = efl_util_gesture_grab(gesture_h, tap_d);
+ ret = gesture_h->grabGesture(tap_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to grab tap gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
etRunner::get().ev.gesture.tap.fingers = 2;
etRunner::get().ev.gesture.tap.repeats = 2;
-
- etRunner::get().generateTapGesture();
+ etRunner::get().generateTapGesture(inputgen_h);
ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
ASSERT_NE(ev_result, nullptr);
etRunner::get().ev.gesture.tap.fingers = 0;
etRunner::get().ev.gesture.tap.repeats = 0;
- ret = efl_util_gesture_ungrab(gesture_h, tap_d);
+ ret = gesture_h->ungrabGesture(tap_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to ungrab tap gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
+ gesture_h->freeTapData(tap_d);
+ ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to free tap grab data: (ret: "
+ << EFL_UTIL_RETURN_TO_STRING(ret) << ")";
+
ASSERT_EQ(etRunner::get().verifyTC(testCaseName, testName), EINA_TRUE);
}
TEST_F(etTestInput, gesture_tap23)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
+ auto inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ GestureHandler gesture_h = std::make_shared<etGestureHandler>();;
efl_util_gesture_data tap_d;
- tap_d = efl_util_gesture_tap_new(gesture_h, 2, 3);
+ tap_d = gesture_h->createTapData(2, 3);
ASSERT_TRUE(tap_d != NULL) << "failed to generate tap grab data";
- ret = efl_util_gesture_grab(gesture_h, tap_d);
+ ret = gesture_h->grabGesture(tap_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to grab tap gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
etRunner::get().ev.gesture.tap.fingers = 2;
etRunner::get().ev.gesture.tap.repeats = 3;
- etRunner::get().generateTapGesture();
+ etRunner::get().generateTapGesture(inputgen_h);
ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_TAP);
ASSERT_NE(ev_result, nullptr);
etRunner::get().ev.gesture.tap.fingers = 0;
etRunner::get().ev.gesture.tap.repeats = 0;
- ret = efl_util_gesture_ungrab(gesture_h, tap_d);
+
+ ret = gesture_h->ungrabGesture(tap_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to ungrab tap gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
- efl_util_gesture_tap_free(gesture_h, tap_d);
+ gesture_h->freeTapData(tap_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to free tap grab data: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
etTestInput::test_gesture_edge_swipe(int fingers, efl_util_gesture_edge_e edge)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
+ auto inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ GestureHandler gesture_h = std::make_shared<etGestureHandler>();;
efl_util_gesture_data edge_swipe_d;
- edge_swipe_d = efl_util_gesture_edge_swipe_new(gesture_h, fingers, edge);
+ edge_swipe_d = gesture_h->createEdgeSwipeData(fingers, edge);
ASSERT_TRUE(edge_swipe_d != NULL) << "failed to generate edge swipe grab data";
- ret = efl_util_gesture_grab(gesture_h, edge_swipe_d);
+ ret = gesture_h->grabGesture(edge_swipe_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to grab edge swipe gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
etRunner::get().ev.gesture.edge.fingers = fingers;
etRunner::get().ev.gesture.edge.edge = edge;
- etRunner::get().generateEdgeSwipeGesture();
+ etRunner::get().generateEdgeSwipeGesture(inputgen_h);
ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_SWIPE);
ASSERT_NE(ev_result, nullptr);
etRunner::get().ev.gesture.edge.fingers = 0;
etRunner::get().ev.gesture.edge.edge = EFL_UTIL_GESTURE_EDGE_NONE;;
- ret = efl_util_gesture_ungrab(gesture_h, edge_swipe_d);
+ ret = gesture_h->ungrabGesture(edge_swipe_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to grab edge swipe gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
- ret = efl_util_gesture_edge_swipe_free(gesture_h, edge_swipe_d);
+ ret = gesture_h->freeEdgeSwipeData(edge_swipe_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to free tap grab data: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
etTestInput::test_gesture_edge_drag(int fingers, efl_util_gesture_edge_e edge)
{
int ret = EFL_UTIL_ERROR_NONE;
- efl_util_gesture_h gesture_h = etRunner::get().getGestureHandler();
+ auto inputgen_h = std::make_shared<etInputGenHandler>(EFL_UTIL_INPUT_DEVTYPE_TOUCHSCREEN);
+ GestureHandler gesture_h = std::make_shared<etGestureHandler>();;
efl_util_gesture_data edge_drag_d;
- edge_drag_d = efl_util_gesture_edge_drag_new(gesture_h, fingers, edge);
+ edge_drag_d = gesture_h->createEdgeDragData(fingers, edge);
ASSERT_TRUE(edge_drag_d != NULL) << "failed to generate edge drag grab data";
- ret = efl_util_gesture_grab(gesture_h, edge_drag_d);
+ ret = gesture_h->grabGesture(edge_drag_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to grab edge drag gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
etRunner::get().ev.gesture.edge.fingers = fingers;
etRunner::get().ev.gesture.edge.edge = edge;
- etRunner::get().generateEdgeDragGesture();
+ etRunner::get().generateEdgeDragGesture(inputgen_h);
ev_result = etRunner::get().waitEvent(NULL, E_TC_EVENT_TYPE_GESTURE_EDGE_DRAG);
ASSERT_NE(ev_result, nullptr);
etRunner::get().ev.gesture.edge.fingers = 0;
etRunner::get().ev.gesture.edge.edge = EFL_UTIL_GESTURE_EDGE_NONE;;
- ret = efl_util_gesture_ungrab(gesture_h, edge_drag_d);
+ ret = gesture_h->ungrabGesture(edge_drag_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to grab edge drag gesture: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
- ret = efl_util_gesture_edge_drag_free(gesture_h, edge_drag_d);
+ ret = gesture_h->freeEdgeDragData(edge_drag_d);
ASSERT_TRUE(ret == EFL_UTIL_ERROR_NONE) << "failed to free tap grab data: (ret: "
<< EFL_UTIL_RETURN_TO_STRING(ret) << ")";
}
projects / platform / core / uifw / e-tizen-testcase.git / commitdiff