From: Gwanglim Lee Date: Wed, 25 Mar 2015 08:04:43 +0000 (+0900) Subject: Code refactoring X-Git-Tag: submit/tizen/20150518.012401~8 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ca0fe0a3a91326923fab216cabbc216e0d2bc14f;p=platform%2Fcore%2Fuifw%2Fe-tizen-testcase.git Code refactoring Change-Id: I4cd5bbddabe6618f616e993ec4a850fef486488a --- diff --git a/src/0000_easy.c b/src/0000_easy.c index 4df3222..77e118d 100644 --- a/src/0000_easy.c +++ b/src/0000_easy.c @@ -1,13 +1,148 @@ -#include "e_test_case_main.h" +#include "e_tc_main.h" + +static void +_cb_introspect(void *data EINA_UNUSED, + const Eldbus_Message *msg, + Eldbus_Pending *pending EINA_UNUSED) +{ + const char *arg, *name = NULL, *text = NULL; + Eina_Bool res; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "s", &arg); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + if ((!strstr(arg, "method name=\"RegisterWindow\"" )) || + (!strstr(arg, "method name=\"DeregisterWindow\"")) || + (!strstr(arg, "method name=\"GetClients\"" )) || + (!strstr(arg, "method name=\"ChangeStack\"" )) || + (!strstr(arg, "signal name=\"ChangeVisibility\"")) || + (!strstr(arg, "signal name=\"Restack\"" )) || + (!strstr(arg, "property name=\"Registrant\"" ))) + { + goto finish; + } + + tc->passed = EINA_TRUE; + +finish: + if (!tc->passed) ERR("errname:%s errmsg:%s\n", name, text); + + elm_exit(); +} + +#define _WIN_ID 0x123456 + +static void +_cb_prop_registrant(void *data, + const Eldbus_Message *msg, + Eldbus_Pending *p EINA_UNUSED) +{ + const char *name = NULL, *text = NULL; + Eldbus_Message_Iter *variant = NULL; + Ecore_Window win; + Eina_Bool res; + char *type; + + tc->passed = EINA_FALSE; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "v", &variant); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + EINA_SAFETY_ON_NULL_GOTO(variant, finish); + + type = eldbus_message_iter_signature_get(variant); + EINA_SAFETY_ON_FALSE_GOTO((type[0] == 'u'), finish); + + res = eldbus_message_iter_arguments_get(variant, "u", &win); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + EINA_SAFETY_ON_FALSE_GOTO((win == _WIN_ID), finish); + + tc->passed = EINA_TRUE; + +finish: + if ((tc) && (!tc->passed)) + { + ERR("errname:%s errmsg:%s\n", name, text); + } + + elm_exit(); +} Eina_Bool -test_case_0000_easy_fail(E_Test_Case *tc EINA_UNUSED) +tc_0000_base_pass(E_TC *tc) { - return EINA_FALSE; + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + tc->passed = EINA_TRUE; + + return tc->passed; } Eina_Bool -test_case_0000_easy_pass(E_Test_Case *tc EINA_UNUSED) +tc_0001_base_fail(E_TC *tc) { - return EINA_TRUE; + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + tc->passed = EINA_FALSE; + + return tc->passed; +} + +Eina_Bool +tc_0010_introspect(E_TC *tc) +{ + Eldbus_Pending *p; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + p = eldbus_object_introspect(tc->runner->dbus.obj, + _cb_introspect, + NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE); + + elm_run(); + + return tc->passed; +} + +Eina_Bool +tc_0011_win_register(E_TC *tc) +{ + Eldbus_Pending *p; + Eina_Bool res; + E_TC_Win *tw = NULL; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + tw = e_tc_win_info_add(_WIN_ID, EINA_FALSE, "tc", 0, 0, 1, 1, 0); + EINA_SAFETY_ON_NULL_GOTO(tw, finish); + + /* check RegisterWindow method */ + res = e_tc_runner_req_win_register(tc->runner, tw); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + /* check whether registered window id is same */ + p = eldbus_proxy_property_get(tc->runner->dbus.proxy, + "Registrant", + _cb_prop_registrant, + tc); + EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE); + + elm_run(); + EINA_SAFETY_ON_FALSE_RETURN_VAL(tc->passed, EINA_FALSE); + + /* check DeregisterWindow method */ + res = e_tc_runner_req_win_deregister(tc->runner, tw); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + tc->passed = EINA_TRUE; + +finish: + e_tc_win_del(tw); + return tc->passed; } diff --git a/src/0001_introspect.c b/src/0001_introspect.c deleted file mode 100644 index 783ef5f..0000000 --- a/src/0001_introspect.c +++ /dev/null @@ -1,53 +0,0 @@ -#include "e_test_case_main.h" - -static Eina_Bool pass = EINA_FALSE; - -static void -_method_cb_introspect(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) -{ - const char *introspect; - const char *errname, *errmsg; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s\n", errname, errmsg); - elm_exit(); - return; - } - - if (!eldbus_message_arguments_get(msg, "s", &introspect)) - { - ERR("Error on eldbus_message_arguments_get()\n"); - elm_exit(); - return; - } - - if ((!strstr(introspect, "method name=\"RegisterWindow\"")) || - (!strstr(introspect, "method name=\"DeregisterWindow\"")) || - (!strstr(introspect, "method name=\"GetClients\"")) || - (!strstr(introspect, "method name=\"ChangeStack\"")) || - (!strstr(introspect, "signal name=\"ChangeVisibility\"")) || - (!strstr(introspect, "signal name=\"Restack\"")) || - (!strstr(introspect, "property name=\"Registrant\""))) - { - elm_exit(); - return; - } - - pass = EINA_TRUE; - elm_exit(); -} - -Eina_Bool -test_case_0001_introspect(E_Test_Case *tc) -{ - - if ((!dbus_conn) || (!dbus_obj) || (!dbus_proxy)) return pass; - - if (!eldbus_object_introspect(dbus_obj, _method_cb_introspect, NULL)) - return pass; - - elm_run(); - - return pass; -} diff --git a/src/0002_deregister.c b/src/0002_deregister.c deleted file mode 100644 index 6fdc3cc..0000000 --- a/src/0002_deregister.c +++ /dev/null @@ -1,98 +0,0 @@ -#include "e_test_case_main.h" - -static const Ecore_Window custom_win = 0x123456; -static Eina_Bool pass = EINA_FALSE; - -static void -_method_cb_deregister_window(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) -{ - Eina_Bool allowed = EINA_FALSE; - const char *errname, *errmsg; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s\n", errname, errmsg); - } - - if (!eldbus_message_arguments_get(msg, "b", &allowed)) - { - ERR("Error on eldbus_message_arguments_get()\n"); - } - - pass = allowed; - elm_exit(); -} - -static void -_property_cb_get_registrant(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) -{ - Ecore_Window win; - Eldbus_Message_Iter *variant = NULL; - Eldbus_Pending *pend = NULL; - char *type; - const char *errname, *errmsg; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("Message error %s - %s\n\n", errname, errmsg); - } - - if (!eldbus_message_arguments_get(msg, "v", &variant)) - { - ERR("Error getting arguments."); - } - - type = eldbus_message_iter_signature_get(variant); - if (type[0] == 'u') - { - if (eldbus_message_iter_arguments_get(variant, "u", &win)) - { - if (win == custom_win) - { - pend = eldbus_proxy_call(dbus_proxy, "DeregisterWindow", - _method_cb_deregister_window, NULL, -1, - "u", custom_win); - if (pend) return; - } - } - } - - elm_exit(); -} - -static void -_method_cb_register_window(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) -{ - Eina_Bool accepted = EINA_FALSE; - const char *errname, *errmsg; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s\n", errname, errmsg); - elm_exit(); - return; - } - - if (!eldbus_message_arguments_get(msg, "b", &accepted)) - { - ERR("Error on eldbus_message_arguments_get()\n"); - elm_exit(); - return; - } - - if (!eldbus_proxy_property_get(dbus_proxy, "Registrant", _property_cb_get_registrant, NULL)) - elm_exit(); -} - -Eina_Bool -test_case_0002_deregister(E_Test_Case *tc) -{ - - if ((!dbus_conn) || (!dbus_obj) || (!dbus_proxy)) return pass; - if (!eldbus_proxy_call(dbus_proxy, "RegisterWindow", _method_cb_register_window, NULL, -1, "u", custom_win)) - return pass; - - elm_run(); - - return pass; -} diff --git a/src/0100_base_operation.c b/src/0100_base_operation.c new file mode 100644 index 0000000..5a41504 --- /dev/null +++ b/src/0100_base_operation.c @@ -0,0 +1,192 @@ +#include "e_tc_main.h" + +struct _E_TC_Data +{ + E_TC_Win *tw; +}; + +static Eina_Bool _tc_pre_run(E_TC *tc, Eina_Bool alpha); +static Eina_Bool _tc_post_run(E_TC *tc); +static void _tc_shutdown(E_TC *tc); + +static Eina_Bool +_tc_pre_run(E_TC *tc, Eina_Bool alpha) +{ + Eina_Bool res; + + tc->data = E_NEW(E_TC_Data, 1); + EINA_SAFETY_ON_NULL_RETURN_VAL(tc->data, EINA_FALSE); + + tc->data->tw = e_tc_win_add(NULL, ELM_WIN_BASIC, + alpha, "tc", + 0, 0, 320, 320, + 200); + EINA_SAFETY_ON_NULL_GOTO(tc->data->tw, cleanup); + + res = e_tc_win_register(tc->data->tw); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + e_tc_win_geom_update(tc->data->tw_child); + e_tc_win_show(tc->data->tw_child); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + return EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + return EINA_FALSE; +} + +static Eina_Bool +_tc_post_run(E_TC *tc) +{ + Eina_Bool res = EINA_FALSE; + + e_tc_win_hide(tc->data->tw); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_VIS_OFF); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + return EINA_TRUE; +} + +static void +_tc_shutdown(E_TC *tc) +{ + EINA_SAFETY_ON_NULL_RETURN(tc->data); + + e_tc_win_deregister(tc->data->tw); + e_tc_win_del(tc->data->tw); + + E_FREE(tc->data); +} + +Eina_Bool +tc_0100_win_show(E_TC *tc) +{ + E_TC_Win *tw = NULL; + Eina_Bool res = EINA_FALSE; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + + return tc->passed; +} + +Eina_Bool +tc_0101_win_stack(E_TC *tc) +{ + E_TC_Win *tw, *tw2; + Eina_Bool res = EINA_FALSE; + Eina_List *clients, *l; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw = tc->data->tw; + + clients = e_tc_req_clients_info_get(tc->main_data); + EINA_SAFETY_ON_NULL_GOTO(clients, cleanup); + + EINA_LIST_FOREACH(clients, l, tw2) + { + if (tw2->layer > tw->layer) continue; + if (tw2->layer < tw->layer) break; + + if (!strncmp(tw2->name, tw->name, strlen(tw2->name))) + res = EINA_TRUE; + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + E_FREE_LIST(clients, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0110_alpha_win_show(E_TC *tc) +{ + E_TC_Win *tw = NULL; + Eina_Bool res = EINA_FALSE; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + + return tc->passed; +} + +Eina_Bool +tc_0111_alpha_win_stack(E_TC *tc) +{ + E_TC_Win *tw, *tw2; + Eina_Bool res = EINA_FALSE; + Eina_List *clients, *l; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw = tc->data->tw; + + clients = e_tc_req_clients_info_get(tc->main_data); + EINA_SAFETY_ON_NULL_GOTO(clients, cleanup); + + EINA_LIST_FOREACH(clients, l, tw2) + { + if (tw2->layer > tw->layer) continue; + if (tw2->layer < tw->layer) break; + + if (!strncmp(tw2->name, tw->name, strlen(tw2->name))) + res = EINA_TRUE; + + break; + } + + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + E_FREE_LIST(clients, e_tc_win_del); + + return tc->passed; +} diff --git a/src/0100_basic.c b/src/0100_basic.c deleted file mode 100644 index 94bfc2d..0000000 --- a/src/0100_basic.c +++ /dev/null @@ -1,122 +0,0 @@ -#include "e_test_case_main.h" -#include "e_test_case_util.h" - -E_TC_Data *_tc_data; - -static E_Test_Case *_test_case = NULL; -static void test(void); - -/* Main test */ -static void -test(void) -{ - _test_case->passed = e_test_case_inner_do(_test_case); - - evas_object_hide(_tc_data->client->obj); - - if (e_test_case_util_deregister_window(_tc_data->client->win)) - return; - - if (e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_OFF)) - return; -} - -Eina_Bool -test_case_0100_basic(E_Test_Case *tc) -{ - Evas_Object *bg, *win; - E_TC_Client client = { NULL, // evas object - "0100_basic", // name - 0, 0, 320, 320, // geometry(x,y,w,h) - 200, //E_LAYER_CLIENT_NORMAL, //layer - -1, -1, 0 // visible, arg, win - }; - - if (!tc) goto test_shutdown; - - _test_case = tc; - - if (_tc_data) E_FREE(_tc_data); - _tc_data = E_NEW(E_TC_Data, 1); - - win = elm_win_add(NULL, client.name, ELM_WIN_BASIC); - client.win = elm_win_xwindow_get(win); - - elm_win_title_set(win, client.name); - elm_win_autodel_set(win, EINA_FALSE); - - bg = elm_bg_add(win); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(win, bg); - elm_bg_color_set(bg, 0, 120, 100); - evas_object_show(bg); - - client.obj = win; - - _tc_data->client = E_NEW(E_TC_Client, 1); - memcpy(_tc_data->client, &client, sizeof(E_TC_Client)); - - if (e_test_case_util_register_window(client.win)) - { - evas_object_move(win, client.x, client.y); - evas_object_resize(win, client.w, client.h); - evas_object_show(win); - } - else - goto test_shutdown; - - if (e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_ON)) - test(); - -test_shutdown: - if (_tc_data) - { - E_TC_Client *_client; - - if (_tc_data->client) - { - evas_object_del(_tc_data->client->obj); - _tc_data->client->obj = NULL; - E_FREE(_tc_data->client); - } - - EINA_LIST_FREE(_tc_data->clients, _client) - { - eina_stringshare_del(_client->name); - E_FREE(_client); - _client = NULL; - } - - E_FREE(_tc_data); - } - - return _test_case->passed; -} - -Eina_Bool -test_case_0101_basic_stack(E_Test_Case *tc EINA_UNUSED) -{ - E_TC_Client *client; - Eina_Bool passed = EINA_FALSE; - Eina_List *l; - - EINA_SAFETY_ON_NULL_RETURN_VAL(_tc_data, EINA_FALSE); - EINA_SAFETY_ON_NULL_RETURN_VAL(_tc_data->client, EINA_FALSE); - - e_test_case_util_get_clients(_tc_data); - - EINA_LIST_FOREACH(_tc_data->clients, l, client) - { - if (client->layer > _tc_data->client->layer) - continue; - if (client->layer < _tc_data->client->layer) - break; - - if (!strncmp(client->name, _tc_data->client->name, strlen(client->name))) - passed = EINA_TRUE; - - break; - } - - return passed; -} diff --git a/src/0110_transient_for.c b/src/0110_transient_for.c deleted file mode 100644 index 685f7d5..0000000 --- a/src/0110_transient_for.c +++ /dev/null @@ -1,337 +0,0 @@ -#include "e_test_case_main.h" -#include "e_test_case_util.h" - -static E_Test_Case *_test_case = NULL; - -E_TC_Data *_tc_data = NULL; -E_TC_Client *_parent, *_child; - -static void test(void); - -/* Main test */ -static void -test(void) -{ - E_TC_Client *client = NULL, *above = NULL; - Eina_List *l; - Eina_Bool passed = EINA_FALSE; - - e_test_case_util_get_clients(_tc_data); - EINA_LIST_FOREACH(_tc_data->clients, l, client) - { - if (client->layer > _tc_data->client->layer) - continue; - if (client->layer < _tc_data->client->layer) - break; - - if (client->win == _parent->win) - { - if ((above) && (above->win == _child->win)) - passed = EINA_TRUE; - - break; - } - - above = client; - } - - _test_case->passed = passed && e_test_case_inner_do(_test_case); - - evas_object_hide(_parent->obj); - evas_object_hide(_child->obj); - evas_object_hide(_tc_data->client->obj); - - if (e_test_case_util_deregister_window(_tc_data->client->win)) - return; - - if (e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_OFF)) - return; -} - -Eina_Bool -test_case_0110_transient_for(E_Test_Case *tc) -{ - Evas_Object *bg, *win; - E_TC_Client client = { NULL, // evas object - "0110_transient_for", // name - 0, 0, 320, 320, // geometry(x,y,w,h) - 200, //E_LAYER_CLIENT_NORMAL, //layer - -1, -1, 0 // visible, arg, win - }; - - if (!tc) goto test_shutdown; - - _test_case = tc; - - if (_tc_data) E_FREE(_tc_data); - _tc_data = E_NEW(E_TC_Data, 1); - - _parent = E_NEW(E_TC_Client, 1); - _parent->obj = elm_win_add(NULL, "parent", ELM_WIN_BASIC); - _parent->win = elm_win_xwindow_get(_parent->obj); - elm_win_title_set(_parent->obj, "parent"); - elm_win_autodel_set(_parent->obj, EINA_FALSE); - - bg = elm_bg_add(_parent->obj); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(_parent->obj, bg); - elm_bg_color_set(bg, 0, 120, 100); - evas_object_show(bg); - - _child = E_NEW(E_TC_Client, 1); - _child->obj = elm_win_add(_parent->obj, "child", ELM_WIN_BASIC); - _child->win = elm_win_xwindow_get(_child->obj); - elm_win_title_set(_child->obj, "child"); - elm_win_autodel_set(_child->obj, EINA_FALSE); - - bg = elm_bg_add(_child->obj); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(_child->obj, bg); - elm_bg_color_set(bg, 0, 0, 150); - evas_object_show(bg); - - win = elm_win_add(NULL, client.name, ELM_WIN_BASIC); - client.win = elm_win_xwindow_get(win); - elm_win_title_set(win, client.name); - elm_win_autodel_set(win, EINA_FALSE); - - bg = elm_bg_add(win); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(win, bg); - elm_bg_color_set(bg, 120,0, 0); - evas_object_show(bg); - - client.obj = win; - - _tc_data->client = E_NEW(E_TC_Client, 1); - memcpy(_tc_data->client, &client, sizeof(E_TC_Client)); - - if (e_test_case_util_register_window(client.win)) - { - evas_object_move(_parent->obj, 0, 0); - evas_object_resize(_parent->obj, 400, 400); - evas_object_show(_parent->obj); - - evas_object_move(win, client.x, client.y); - evas_object_resize(win, client.w, client.h); - evas_object_show(win); - - evas_object_move(_child->obj, 0, 0); - evas_object_resize(_child->obj, 200, 200); - evas_object_show(_child->obj); - } - else - goto test_shutdown; - - if (e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_CHANGED)) - test(); - -test_shutdown: - if (_tc_data) - { - E_TC_Client *_client; - - if (_tc_data->client) - { - evas_object_del(_tc_data->client->obj); - _tc_data->client->obj = NULL; - E_FREE(_tc_data->client); - } - - if (_parent) - { - evas_object_del(_parent->obj); - _parent->obj = NULL; - E_FREE(_parent); - } - - if (_child) - { - evas_object_del(_child->obj); - _child->obj = NULL; - E_FREE(_child); - } - - EINA_LIST_FREE(_tc_data->clients, _client) - { - eina_stringshare_del(_client->name); - E_FREE(_client); - _client = NULL; - } - - E_FREE(_tc_data); - } - - return _test_case->passed; -} - -Eina_Bool -test_case_0111_transient_for_raise(E_Test_Case *tc) -{ - E_TC_Client *client = NULL, *above = NULL; - Eina_List *l; - Eina_Bool passed = EINA_FALSE; - - EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - EINA_SAFETY_ON_NULL_RETURN_VAL(_tc_data, EINA_FALSE); - - if (!e_test_case_util_change_stack(_parent->win, 0, E_TEST_CASE_STACK_TYPE_RAISE)) - return EINA_FALSE; - - if (!e_test_case_util_wait_restack()) - return EINA_FALSE; - - e_test_case_util_get_clients(_tc_data); - EINA_LIST_FOREACH(_tc_data->clients, l, client) - { - if (client->layer > _tc_data->client->layer) - continue; - if (client->layer < _tc_data->client->layer) - break; - - if (client->win == _parent->win) - { - if ((above) && (above->win == _child->win)) - passed = EINA_TRUE; - - break; - } - else if (client->win != _child->win) - break; - - above = client; - } - - return passed; - -} - -Eina_Bool -test_case_0112_transient_for_lower(E_Test_Case *tc) -{ - E_TC_Client *client = NULL, *above = NULL; - Eina_List *l; - Eina_Bool passed = EINA_FALSE; - - EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - EINA_SAFETY_ON_NULL_RETURN_VAL(_tc_data, EINA_FALSE); - - if (!e_test_case_util_change_stack(_parent->win, 0, E_TEST_CASE_STACK_TYPE_LOWER)) - return EINA_FALSE; - - if (!e_test_case_util_wait_restack()) - return EINA_FALSE; - - e_test_case_util_get_clients(_tc_data); - EINA_LIST_FOREACH(_tc_data->clients, l, client) - { - if (client->layer > _tc_data->client->layer) - continue; - if (client->layer < _tc_data->client->layer) - break; - - if ((passed) && (above) && (above->win == _parent->win)) - { - passed = EINA_FALSE; - break; - } - - if (client->win == _parent->win) - { - if ((above) && (above->win == _child->win)) - passed = EINA_TRUE; - } - - above = client; - } - - return passed; - -} - -Eina_Bool -test_case_0113_transient_for_stack_above(E_Test_Case *tc) -{ - E_TC_Client *client = NULL, *above = NULL; - Eina_List *l; - Eina_Bool passed = EINA_FALSE; - - EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - EINA_SAFETY_ON_NULL_RETURN_VAL(_tc_data, EINA_FALSE); - - if (!e_test_case_util_change_stack(_parent->win, _tc_data->client->win, E_TEST_CASE_STACK_TYPE_ABOVE)) - return EINA_FALSE; - - if (!e_test_case_util_wait_restack()) - return EINA_FALSE; - - e_test_case_util_get_clients(_tc_data); - EINA_LIST_FOREACH(_tc_data->clients, l, client) - { - if (client->layer > _tc_data->client->layer) - continue; - if (client->layer < _tc_data->client->layer) - break; - - if (client->win == _parent->win) - { - if ((above) && (above->win == _child->win)) - passed = EINA_TRUE; - - break; - } - - above = client; - } - - return passed; - -} - -Eina_Bool -test_case_0114_transient_for_stack_below(E_Test_Case *tc) -{ - E_TC_Client *client = NULL, *above = NULL; - Eina_List *l; - Eina_Bool passed = EINA_FALSE; - - EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); - EINA_SAFETY_ON_NULL_RETURN_VAL(_tc_data, EINA_FALSE); - - if (!e_test_case_util_change_stack(_parent->win, _tc_data->client->win, E_TEST_CASE_STACK_TYPE_BELOW)) - return EINA_FALSE; - - if (!e_test_case_util_wait_restack()) - return EINA_FALSE; - - e_test_case_util_get_clients(_tc_data); - EINA_LIST_FOREACH(_tc_data->clients, l, client) - { - if (client->layer > _tc_data->client->layer) - continue; - if (client->layer < _tc_data->client->layer) - break; - - if (client->win == _parent->win) - { - if ((above) && (above->win == _child->win)) - passed = EINA_TRUE; - - break; - } - else if (client->win == _child->win) - { - if ((!above) || (above->win != _tc_data->client->win)) - { - passed = EINA_FALSE; - break; - } - } - - - above = client; - } - - return passed; - -} diff --git a/src/0120_notification_level.c b/src/0120_notification_level.c deleted file mode 100644 index faef6f5..0000000 --- a/src/0120_notification_level.c +++ /dev/null @@ -1,339 +0,0 @@ -#include "e_test_case_main.h" -#include "e_test_case_util.h" - -#include - -#define TC_NWIN_W 400 -#define TC_NWIN_H 400 - -typedef struct -{ - Evas_Object *obj; - Ecore_Window win; -} E_TC_Win; - -static E_TC_Win *_tc_normal_win; -static E_TC_Win *_tc_noti_win1; -static E_TC_Win *_tc_noti_win2; - -static Eina_Bool registered; -static Eina_Bool loop_running; - -static Eina_Bool -_notification_level_windows_show(E_Test_Case *tc) -{ - Eldbus_Pending *ret; - - if (!(e_test_case_util_register_window(_tc_normal_win->win))) - return EINA_FALSE; - - registered = EINA_TRUE; - evas_object_show(_tc_normal_win->obj); - evas_object_show(_tc_noti_win1->obj); - evas_object_show(_tc_noti_win2->obj); - - if (!(e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_CHANGED))) - return EINA_FALSE; - - return EINA_TRUE; -} - -static void -_notification_level_windows_hide(E_Test_Case *tc) -{ - if (!registered) return; - - evas_object_hide(_tc_noti_win2->obj); - evas_object_hide(_tc_noti_win1->obj); - evas_object_hide(_tc_normal_win->obj); - - if (e_test_case_util_deregister_window(_tc_normal_win->win)) - return; - - if (e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_OFF)) - return; -} - -static void -_notification_level_windows_destroy(E_Test_Case *tc) -{ - if (_tc_noti_win2) - { - evas_object_del(_tc_noti_win2->obj); - E_FREE(_tc_noti_win2); - } - if (_tc_noti_win1) - { - evas_object_del(_tc_noti_win1->obj); - E_FREE(_tc_noti_win1); - } - if (_tc_normal_win) - { - evas_object_del(_tc_normal_win->obj); - E_FREE(_tc_normal_win); - } -} - -static Eina_Bool -_notification_level_windows_create(E_Test_Case *tc) -{ - if (!_tc_normal_win) - { - Evas_Object *bg; - - _tc_normal_win = E_NEW(E_TC_Win, 1); - EINA_SAFETY_ON_NULL_GOTO(_tc_normal_win, create_fail); - - _tc_normal_win->obj = elm_win_add(NULL, "_tc_normal_win", ELM_WIN_BASIC); - _tc_normal_win->win = elm_win_xwindow_get(_tc_normal_win->obj); - elm_win_title_set(_tc_normal_win->obj, "_tc_normal_win"); - elm_win_autodel_set(_tc_normal_win->obj, EINA_FALSE); - - bg = elm_bg_add(_tc_normal_win->obj); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(_tc_normal_win->obj, bg); - elm_bg_color_set(bg, 0xff, 0, 0); - evas_object_show(bg); - } - - if (!_tc_noti_win1) - { - Evas_Object *bg; - - _tc_noti_win1 = E_NEW(E_TC_Win, 1); - EINA_SAFETY_ON_NULL_GOTO(_tc_noti_win1, create_fail); - - _tc_noti_win1->obj = elm_win_add(NULL, "_tc_noti_win1", ELM_WIN_NOTIFICATION); - _tc_noti_win1->win = elm_win_xwindow_get(_tc_noti_win1->obj); - elm_win_title_set(_tc_noti_win1->obj, "_tc_noti_win1"); - elm_win_autodel_set(_tc_noti_win1->obj, EINA_FALSE); - - bg = elm_bg_add(_tc_noti_win1->obj); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(_tc_noti_win1->obj, bg); - elm_bg_color_set(bg, 0, 0, 0xff); - evas_object_show(bg); - } - - if (!_tc_noti_win2) - { - Evas_Object *bg; - - _tc_noti_win2 = E_NEW(E_TC_Win, 1); - EINA_SAFETY_ON_NULL_GOTO(_tc_noti_win2, create_fail); - - _tc_noti_win2->obj = elm_win_add(NULL, "_tc_noti_win2", ELM_WIN_NOTIFICATION); - _tc_noti_win2->win = elm_win_xwindow_get(_tc_noti_win2->obj); - elm_win_title_set(_tc_noti_win2->obj, "_tc_noti_win2"); - elm_win_autodel_set(_tc_noti_win2->obj, EINA_FALSE); - - bg = elm_bg_add(_tc_noti_win2->obj); - evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(_tc_noti_win2->obj, bg); - elm_bg_color_set(bg, 0, 0, 0xff); - evas_object_show(bg); - } - - return EINA_TRUE; - -create_fail: - _notification_level_windows_destroy(tc); - - return EINA_FALSE; -} - -static void -_notification_level_tc_finish(E_Test_Case *tc) -{ - _notification_level_windows_destroy(tc); - - registered = EINA_FALSE; -} - -static Eina_Bool -_notification_level_tc_prepare(E_Test_Case *tc) -{ - if (!_notification_level_windows_create(tc)) return EINA_FALSE; - - registered = EINA_FALSE; - - return EINA_TRUE; -} - -static Eina_Bool -_notification_level_check_stack(E_Test_Case *tc, - E_TC_Win *bottom, - E_TC_Win *middle, - E_TC_Win *top) -{ - E_TC_Data tc_data = {0,}; - E_TC_Client *client = NULL; - Eina_List *l; - int t_layer = 0, m_layer = 0, b_layer = 0; - - e_test_case_util_get_clients(&tc_data); - - EINA_LIST_FOREACH(tc_data.clients, l, client) - { - if (top->win == client->win) - { - t_layer = client->layer; - continue; - } - else if (middle->win == client->win) - { - m_layer = client->layer; - continue; - } - else if (bottom->win == client->win) - { - b_layer = client->layer; - continue; - } - } - - if (b_layer < m_layer && m_layer < t_layer) - return EINA_TRUE; - - return EINA_FALSE; -} - -Eina_Bool -test_case_0120_notification_level(E_Test_Case *tc) -{ - Eina_Bool passed = EINA_TRUE; - - passed = passed && e_test_case_inner_do(tc); - - return passed; -} - -Eina_Bool -test_case_0121_notification_level_1(E_Test_Case *tc) -{ - efl_util_notification_level_e level = -1; - int ret; - Eina_Bool result = EINA_FALSE; - - EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); - - if (!_notification_level_tc_prepare(tc)) goto test_shutdown; - - ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, - EFL_UTIL_NOTIFICATION_LEVEL_1); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - - ret = efl_util_get_notification_window_level(_tc_noti_win1->obj, &level); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - EINA_SAFETY_ON_FALSE_GOTO(level == EFL_UTIL_NOTIFICATION_LEVEL_1, test_shutdown); - - if (!_notification_level_windows_show(tc)) goto test_shutdown; - - result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); - EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); - -test_shutdown: - _notification_level_windows_hide(tc); - _notification_level_tc_finish(tc); - - return result; -} - -Eina_Bool -test_case_0122_notification_level_2(E_Test_Case *tc) -{ - efl_util_notification_level_e level = -1; - int ret; - Eina_Bool result = EINA_FALSE; - - EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); - - if (!_notification_level_tc_prepare(tc)) goto test_shutdown; - - ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, - EFL_UTIL_NOTIFICATION_LEVEL_2); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - - ret = efl_util_get_notification_window_level(_tc_noti_win1->obj, &level); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - EINA_SAFETY_ON_FALSE_GOTO(level == EFL_UTIL_NOTIFICATION_LEVEL_2, test_shutdown); - - if (!_notification_level_windows_show(tc)) goto test_shutdown; - - result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); - EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); - -test_shutdown: - _notification_level_windows_hide(tc); - _notification_level_tc_finish(tc); - - return result; -} - -Eina_Bool -test_case_0123_notification_level_3(E_Test_Case *tc) -{ - efl_util_notification_level_e level = -1; - int ret; - Eina_Bool result = EINA_FALSE; - - EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); - - if (!_notification_level_tc_prepare(tc)) goto test_shutdown; - - ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, - EFL_UTIL_NOTIFICATION_LEVEL_3); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - - ret = efl_util_get_notification_window_level(_tc_noti_win1->obj, &level); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - EINA_SAFETY_ON_FALSE_GOTO(level == EFL_UTIL_NOTIFICATION_LEVEL_3, test_shutdown); - - if (!_notification_level_windows_show(tc)) goto test_shutdown; - - result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); - EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); - -test_shutdown: - _notification_level_windows_hide(tc); - _notification_level_tc_finish(tc); - - return result; -} - -Eina_Bool -test_case_0124_notification_level_change(E_Test_Case *tc) -{ - int ret; - Eina_Bool result = EINA_FALSE; - - EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); - - if (!_notification_level_tc_prepare(tc)) goto test_shutdown; - - ret = efl_util_set_notification_window_level(_tc_noti_win2->obj, - EFL_UTIL_NOTIFICATION_LEVEL_2); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - - ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, - EFL_UTIL_NOTIFICATION_LEVEL_3); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - - if (!_notification_level_windows_show(tc)) goto test_shutdown; - - result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); - EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); - - ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, - EFL_UTIL_NOTIFICATION_LEVEL_1); - EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); - - result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win1, _tc_noti_win2); - EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); - -test_shutdown: - _notification_level_windows_hide(tc); - _notification_level_tc_finish(tc); - - return result; -} diff --git a/src/0200_transient_for.c b/src/0200_transient_for.c new file mode 100644 index 0000000..e6a9752 --- /dev/null +++ b/src/0200_transient_for.c @@ -0,0 +1,333 @@ +#include "e_tc_main.h" + +struct _E_TC_Data +{ + E_TC_Win *tw; + E_TC_Win *tw_parent; + E_TC_Win *tw_child; +}; + +static Eina_Bool _tc_pre_run(E_TC *tc); +static Eina_Bool _tc_post_run(E_TC *tc); +static void _tc_shutdown(E_TC *tc); + +static Eina_Bool +_tc_pre_run(E_TC *tc) +{ + Eina_Bool res; + + tc->data = E_NEW(E_TC_Data, 1); + EINA_SAFETY_ON_NULL_RETURN_VAL(tc->data, EINA_FALSE); + + tc->data->tw_parent = e_tc_win_add(NULL, ELM_WIN_BASIC, + EINA_FALSE, "parent", + 0, 0, 400, 400, + 200); + EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_parent, cleanup); + + tc->data->tw_child = e_tc_win_add(tc->data->tw_parent, ELM_WIN_BASIC, + EINA_FALSE, "child", + 0, 0, 320, 320, + 200); + EINA_SAFETY_ON_NULL_GOTO(tc->data->tw_child, cleanup); + + tc->data->tw = e_tc_win_add(NULL, ELM_WIN_BASIC, + EINA_FALSE, "tc", + 0, 0, 200, 200, + 200); + EINA_SAFETY_ON_NULL_GOTO(tc->data->tw, cleanup); + + res = e_tc_win_register(tc->data->tw); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + e_tc_win_geom_update(tc->data->tw_parent); + e_tc_win_show(tc->data->tw_parent); + + e_tc_win_geom_update(tc->data->tw); + e_tc_win_show(tc->data->tw); + + e_tc_win_geom_update(tc->data->tw_child); + e_tc_win_show(tc->data->tw_child); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_VIS_ON); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + return EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + return EINA_FALSE; +} + +static Eina_Bool +_tc_post_run(E_TC *tc) +{ + Eina_Bool res = EINA_FALSE; + + e_tc_win_hide(tc->data->tw_child); + e_tc_win_hide(tc->data->tw); + e_tc_win_hide(tc->data->tw_parent); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_VIS_OFF); + EINA_SAFETY_ON_FALSE_RETURN_VAL(res, EINA_FALSE); + + return EINA_TRUE; +} + +static void +_tc_shutdown(E_TC *tc) +{ + EINA_SAFETY_ON_NULL_RETURN(tc->data); + + e_tc_win_deregister(tc->data->tw); + e_tc_win_del(tc->data->tw_parent); + e_tc_win_del(tc->data->tw); + e_tc_win_del(tc->data->tw_child); + + E_FREE(tc->data); +} + +Eina_Bool +tc_0200_transient_for_basic(E_TC *tc) +{ + E_TC_Win *tw, *tw2, *tw_parent, *tw_child; + E_TC_Win *tw_above = NULL; + Eina_Bool res = EINA_FALSE; + Eina_List *clients, *l; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + clients = e_tc_req_clients_info_get(tc->main_data); + EINA_SAFETY_ON_NULL_GOTO(clients, cleanup); + + tw = tc->data->tw; + tw_parent = tc->data->tw_parent; + tw_child = tc->data->tw_child; + + EINA_LIST_FOREACH(clients, l, tw2) + { + if (tw2->layer > tw->layer) continue; + if (tw2->layer < tw->layer) break; + + if (tw2->native_win == tw_parent->native_win) + { + if ((tw_above) && + (tw_above->native_win == tw_child->native_win)) + res = EINA_TRUE; + break; + } + + tw_above = tw2; + } + + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + E_FREE_LIST(clients, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0201_transient_for_raise(E_TC *tc) +{ + E_TC_Win *tw, *tw2; + Eina_Bool res = EINA_FALSE; + Eina_List *clients; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw = tc->data->tw; + + res = e_tc_win_stack_change(tw, NULL, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_STACK_RAISE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + clients = e_tc_req_clients_info_get(tc->main_data); + EINA_SAFETY_ON_NULL_GOTO(clients, cleanup); + + tw2 = eina_list_nth(clients, 0); + EINA_SAFETY_ON_NULL_GOTO(tw2, cleanup); + EINA_SAFETY_ON_FALSE_GOTO(tw2->native_win == tw->native_win, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + E_FREE_LIST(clients, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0202_transient_for_lower(E_TC *tc) +{ + E_TC_Win *tw, *tw2; + Eina_Bool res = EINA_FALSE; + Eina_List *clients; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw = tc->data->tw; + + res = e_tc_win_stack_change(tw, NULL, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_STACK_LOWER); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + clients = e_tc_req_clients_info_get(tc->main_data); + EINA_SAFETY_ON_NULL_GOTO(clients, cleanup); + + tw2 = eina_list_last_data_get(clients); + EINA_SAFETY_ON_NULL_GOTO(tw2, cleanup); + EINA_SAFETY_ON_FALSE_GOTO(tw2->native_win == tw->native_win, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tc->passed = EINA_TRUE; + +cleanup: + _tc_shutdown(tc); + E_FREE_LIST(clients, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0203_transient_for_stack_above(E_TC *tc) +{ + E_TC_Win *tw, *tw2, *tw_parent, *tw_child; + E_TC_Win *tw_above = NULL; + Eina_Bool res = EINA_FALSE; + Eina_List *clients, *l; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw = tc->data->tw; + tw_parent = tc->data->tw_parent; + tw_child = tc->data->tw_child; + + res = e_tc_win_stack_change(tw_parent, tw, EINA_TRUE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_STACK_ABOVE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + clients = e_tc_req_clients_info_get(tc->main_data); + EINA_SAFETY_ON_NULL_GOTO(clients, cleanup); + + EINA_LIST_FOREACH(clients, l, tw2) + { + if (tw2->layer > tw->layer) continue; + if (tw2->layer < tw->layer) break; + + if (tw2->native_win == tw_parent->native_win) + { + if ((tw_above) && + (tw_above->native_win == tw_child->native_win)) + res = EINA_TRUE; + break; + } + + tw_above = tw2; + } + + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + +cleanup: + _tc_shutdown(tc); + E_FREE_LIST(clients, e_tc_win_del); + + return tc->passed; +} + +Eina_Bool +tc_0204_transient_for_stack_below(E_TC *tc) +{ + E_TC_Win *tw, *tw2, *tw_parent, *tw_child; + E_TC_Win *tw_above = NULL; + Eina_Bool res = EINA_FALSE; + Eina_List *clients, *l; + + EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE); + + res = _tc_pre_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + tw = tc->data->tw; + tw_parent = tc->data->tw_parent; + tw_child = tc->data->tw_child; + + res = e_tc_win_stack_change(tw_parent, tw, EINA_FALSE); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = e_tc_ev_wait(E_TC_EVENT_TYPE_STACK_BELOW); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + clients = e_tc_req_clients_info_get(tc->main_data); + EINA_SAFETY_ON_NULL_GOTO(clients, cleanup); + + EINA_LIST_FOREACH(clients, l, tw2) + { + if (tw2->layer > tw->layer) continue; + if (tw2->layer < tw->layer) break; + + if (tw2->native_win == tw_parent->native_win) + { + if ((tw_above) && + (tw_above->native_win == tw_child->native_win)) + res = EINA_TRUE; + break; + } + else if (tw2->native_win == tw_child->native_win) + { + if ((!tw_above) || + (tw_above->native_win != tw->native_win)) + { + res = EINA_FALSE; + break; + } + } + + tw_above = tw2; + } + + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + + res = _tc_post_run(tc); + EINA_SAFETY_ON_FALSE_GOTO(res, cleanup); + +cleanup: + _tc_shutdown(tc); + E_FREE_LIST(clients, e_tc_win_del); + + return tc->passed; +} diff --git a/src/0300_notification.c b/src/0300_notification.c new file mode 100644 index 0000000..1ec68bb --- /dev/null +++ b/src/0300_notification.c @@ -0,0 +1,339 @@ +#include +#include "e_tc_main.h" + +#if 0 +#define TC_NWIN_W 400 +#define TC_NWIN_H 400 + +typedef struct +{ + Evas_Object *obj; + Ecore_Window win; +} E_TC_Win; + +static E_TC_Win *_tc_normal_win; +static E_TC_Win *_tc_noti_win1; +static E_TC_Win *_tc_noti_win2; + +static Eina_Bool registered; +static Eina_Bool loop_running; + +static Eina_Bool +_notification_level_windows_show(E_Test_Case *tc) +{ + Eldbus_Pending *ret; + + if (!(e_test_case_util_register_window(_tc_normal_win->win))) + return EINA_FALSE; + + registered = EINA_TRUE; + evas_object_show(_tc_normal_win->obj); + evas_object_show(_tc_noti_win1->obj); + evas_object_show(_tc_noti_win2->obj); + + if (!(e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_CHANGED))) + return EINA_FALSE; + + return EINA_TRUE; +} + +static void +_notification_level_windows_hide(E_Test_Case *tc) +{ + if (!registered) return; + + evas_object_hide(_tc_noti_win2->obj); + evas_object_hide(_tc_noti_win1->obj); + evas_object_hide(_tc_normal_win->obj); + + if (e_test_case_util_deregister_window(_tc_normal_win->win)) + return; + + if (e_test_case_util_wait_visibility_change(E_TEST_CASE_WAIT_VIS_TYPE_OFF)) + return; +} + +static void +_notification_level_windows_destroy(E_Test_Case *tc) +{ + if (_tc_noti_win2) + { + evas_object_del(_tc_noti_win2->obj); + E_FREE(_tc_noti_win2); + } + if (_tc_noti_win1) + { + evas_object_del(_tc_noti_win1->obj); + E_FREE(_tc_noti_win1); + } + if (_tc_normal_win) + { + evas_object_del(_tc_normal_win->obj); + E_FREE(_tc_normal_win); + } +} + +static Eina_Bool +_notification_level_windows_create(E_Test_Case *tc) +{ + if (!_tc_normal_win) + { + Evas_Object *bg; + + _tc_normal_win = E_NEW(E_TC_Win, 1); + EINA_SAFETY_ON_NULL_GOTO(_tc_normal_win, create_fail); + + _tc_normal_win->obj = elm_win_add(NULL, "_tc_normal_win", ELM_WIN_BASIC); + _tc_normal_win->win = elm_win_xwindow_get(_tc_normal_win->obj); + elm_win_title_set(_tc_normal_win->obj, "_tc_normal_win"); + elm_win_autodel_set(_tc_normal_win->obj, EINA_FALSE); + + bg = elm_bg_add(_tc_normal_win->obj); + evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_win_resize_object_add(_tc_normal_win->obj, bg); + elm_bg_color_set(bg, 0xff, 0, 0); + evas_object_show(bg); + } + + if (!_tc_noti_win1) + { + Evas_Object *bg; + + _tc_noti_win1 = E_NEW(E_TC_Win, 1); + EINA_SAFETY_ON_NULL_GOTO(_tc_noti_win1, create_fail); + + _tc_noti_win1->obj = elm_win_add(NULL, "_tc_noti_win1", ELM_WIN_NOTIFICATION); + _tc_noti_win1->win = elm_win_xwindow_get(_tc_noti_win1->obj); + elm_win_title_set(_tc_noti_win1->obj, "_tc_noti_win1"); + elm_win_autodel_set(_tc_noti_win1->obj, EINA_FALSE); + + bg = elm_bg_add(_tc_noti_win1->obj); + evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_win_resize_object_add(_tc_noti_win1->obj, bg); + elm_bg_color_set(bg, 0, 0, 0xff); + evas_object_show(bg); + } + + if (!_tc_noti_win2) + { + Evas_Object *bg; + + _tc_noti_win2 = E_NEW(E_TC_Win, 1); + EINA_SAFETY_ON_NULL_GOTO(_tc_noti_win2, create_fail); + + _tc_noti_win2->obj = elm_win_add(NULL, "_tc_noti_win2", ELM_WIN_NOTIFICATION); + _tc_noti_win2->win = elm_win_xwindow_get(_tc_noti_win2->obj); + elm_win_title_set(_tc_noti_win2->obj, "_tc_noti_win2"); + elm_win_autodel_set(_tc_noti_win2->obj, EINA_FALSE); + + bg = elm_bg_add(_tc_noti_win2->obj); + evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_win_resize_object_add(_tc_noti_win2->obj, bg); + elm_bg_color_set(bg, 0, 0, 0xff); + evas_object_show(bg); + } + + return EINA_TRUE; + +create_fail: + _notification_level_windows_destroy(tc); + + return EINA_FALSE; +} + +static void +_notification_level_tc_finish(E_Test_Case *tc) +{ + _notification_level_windows_destroy(tc); + + registered = EINA_FALSE; +} + +static Eina_Bool +_notification_level_tc_prepare(E_Test_Case *tc) +{ + if (!_notification_level_windows_create(tc)) return EINA_FALSE; + + registered = EINA_FALSE; + + return EINA_TRUE; +} + +static Eina_Bool +_notification_level_check_stack(E_Test_Case *tc, + E_TC_Win *bottom, + E_TC_Win *middle, + E_TC_Win *top) +{ + E_TC_Data tc_data = {0,}; + E_TC_Client *client = NULL; + Eina_List *l; + int t_layer = 0, m_layer = 0, b_layer = 0; + + e_test_case_util_get_clients(&tc_data); + + EINA_LIST_FOREACH(tc_data.clients, l, client) + { + if (top->win == client->win) + { + t_layer = client->layer; + continue; + } + else if (middle->win == client->win) + { + m_layer = client->layer; + continue; + } + else if (bottom->win == client->win) + { + b_layer = client->layer; + continue; + } + } + + if (b_layer < m_layer && m_layer < t_layer) + return EINA_TRUE; + + return EINA_FALSE; +} + +Eina_Bool +test_case_0120_notification_level(E_Test_Case *tc) +{ + Eina_Bool passed = EINA_TRUE; + + passed = passed && e_test_case_inner_do(tc); + + return passed; +} + +Eina_Bool +test_case_0121_notification_level_1(E_Test_Case *tc) +{ + efl_util_notification_level_e level = -1; + int ret; + Eina_Bool result = EINA_FALSE; + + EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); + + if (!_notification_level_tc_prepare(tc)) goto test_shutdown; + + ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, + EFL_UTIL_NOTIFICATION_LEVEL_1); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + + ret = efl_util_get_notification_window_level(_tc_noti_win1->obj, &level); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + EINA_SAFETY_ON_FALSE_GOTO(level == EFL_UTIL_NOTIFICATION_LEVEL_1, test_shutdown); + + if (!_notification_level_windows_show(tc)) goto test_shutdown; + + result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); + EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); + +test_shutdown: + _notification_level_windows_hide(tc); + _notification_level_tc_finish(tc); + + return result; +} + +Eina_Bool +test_case_0122_notification_level_2(E_Test_Case *tc) +{ + efl_util_notification_level_e level = -1; + int ret; + Eina_Bool result = EINA_FALSE; + + EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); + + if (!_notification_level_tc_prepare(tc)) goto test_shutdown; + + ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, + EFL_UTIL_NOTIFICATION_LEVEL_2); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + + ret = efl_util_get_notification_window_level(_tc_noti_win1->obj, &level); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + EINA_SAFETY_ON_FALSE_GOTO(level == EFL_UTIL_NOTIFICATION_LEVEL_2, test_shutdown); + + if (!_notification_level_windows_show(tc)) goto test_shutdown; + + result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); + EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); + +test_shutdown: + _notification_level_windows_hide(tc); + _notification_level_tc_finish(tc); + + return result; +} + +Eina_Bool +test_case_0123_notification_level_3(E_Test_Case *tc) +{ + efl_util_notification_level_e level = -1; + int ret; + Eina_Bool result = EINA_FALSE; + + EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); + + if (!_notification_level_tc_prepare(tc)) goto test_shutdown; + + ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, + EFL_UTIL_NOTIFICATION_LEVEL_3); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + + ret = efl_util_get_notification_window_level(_tc_noti_win1->obj, &level); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + EINA_SAFETY_ON_FALSE_GOTO(level == EFL_UTIL_NOTIFICATION_LEVEL_3, test_shutdown); + + if (!_notification_level_windows_show(tc)) goto test_shutdown; + + result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); + EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); + +test_shutdown: + _notification_level_windows_hide(tc); + _notification_level_tc_finish(tc); + + return result; +} + +Eina_Bool +test_case_0124_notification_level_change(E_Test_Case *tc) +{ + int ret; + Eina_Bool result = EINA_FALSE; + + EINA_SAFETY_ON_NULL_GOTO(tc, test_shutdown); + + if (!_notification_level_tc_prepare(tc)) goto test_shutdown; + + ret = efl_util_set_notification_window_level(_tc_noti_win2->obj, + EFL_UTIL_NOTIFICATION_LEVEL_2); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + + ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, + EFL_UTIL_NOTIFICATION_LEVEL_3); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + + if (!_notification_level_windows_show(tc)) goto test_shutdown; + + result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win2, _tc_noti_win1); + EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); + + ret = efl_util_set_notification_window_level(_tc_noti_win1->obj, + EFL_UTIL_NOTIFICATION_LEVEL_1); + EINA_SAFETY_ON_FALSE_GOTO(ret == EFL_UTIL_ERROR_NONE, test_shutdown); + + result = _notification_level_check_stack (tc, _tc_normal_win, _tc_noti_win1, _tc_noti_win2); + EINA_SAFETY_ON_FALSE_GOTO(result, test_shutdown); + +test_shutdown: + _notification_level_windows_hide(tc); + _notification_level_tc_finish(tc); + + return result; +} +#endif diff --git a/src/Makefile.am b/src/Makefile.am index 6ea4e72..37f17c3 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -8,16 +8,12 @@ e_test_case_LDADD = \ @E_TEST_CASE_LIBS@ e_test_case_SOURCES = \ -e_test_case_main.c \ -e_test_case_main.h \ -e_test_case_util.c \ -e_test_case_util.h \ +e_tc_main.c \ +e_tc_main.h \ 0000_easy.c \ -0001_introspect.c \ -0002_deregister.c \ -0100_basic.c \ -0110_transient_for.c \ -0120_notification_level.c +0100_base_operation.c \ +0200_transient_for.c \ +0300_notification.c MAINTAINERCLEANFILES = \ Makefile.in diff --git a/src/e_tc_main.c b/src/e_tc_main.c new file mode 100644 index 0000000..7497fd9 --- /dev/null +++ b/src/e_tc_main.c @@ -0,0 +1,639 @@ +#include "e_tc_main.h" + +int _log_dom = -1; + +static void +_cb_method_win_info_list_get(void *data, + const Eldbus_Message *msg, + Eldbus_Pending *p EINA_UNUSED) +{ + const char *name = NULL, *text = NULL; + Eldbus_Message_Iter *array, *ec; + Ecore_Window target_win = 0; + Eina_List *list = data; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "ua(usiiiiibb)", &target_win, &array); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + list = eina_list_free(list); + + while (eldbus_message_iter_get_and_next(array, 'r', &ec)) + { + const char *win_name; + int x, y, w, h, layer; + Eina_Bool visible, alpha; + Ecore_Window native_win; + E_TC_Win *tw = NULL; + + res = eldbus_message_iter_arguments_get(ec, + "usiiiiibb", + &native_win, + &win_name, + &x, + &y, + &w, + &h, + &layer, + &visible, + &alpha); + if (!res) + { + WRN("Failed to get win info\n"); + continue; + } + + tw = e_tc_win_info_add(native_win, alpha, win_name, x, y, w, h, layer); + list = eina_list_append(list, tw); + } + +finish: + if ((name) || (text)) + { + ERR("errname:%s errmsg:%s\n", name, text); + } + + elm_exit(); +} + +static void +_cb_method_window_register(void *data, + const Eldbus_Message *msg, + Eldbus_Pending *p EINA_UNUSED) +{ + E_TC *tc = (E_TC *)data; + const char *name = NULL, *text = NULL; + Eina_Bool res; + Eina_Bool *accepted = data; + + EINA_SAFETY_ON_NULL_GOTO(tc, finish); + + *accepted = EINA_FALSE; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "b", accepted); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + +finish: + if ((name) || (text)) + { + ERR("errname:%s errmsg:%s\n", name, text); + } + + elm_exit(); +} + +static void +_cb_method_window_deregister(void *data, + const Eldbus_Message *msg, + Eldbus_Pending *p EINA_UNUSED) +{ + const char *name = NULL, *text = NULL; + Eina_Bool res; + Eina_Bool *allowed = data; + + *allowed = EINA_FALSE; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "b", &allowed); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + +finish: + if ((name) || (text)) + { + ERR("errname:%s errmsg:%s\n", name, text); + } + + elm_exit(); +} + +static void +_cb_signal_vis_changed(void *data, + const Eldbus_Message *msg) +{ + E_TC_Runner *runner = data; + const char *name = NULL, *text = NULL; + Eina_Bool res; + int vis = 0; + Ecore_Window id; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + res = eldbus_message_arguments_get(msg, "ub", &id, &vis); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + /* TODO */ + if (((E_TC_EVENT_TYPE_VIS_ON == runner->ev.expect) && ( vis)) || + ((E_TC_EVENT_TYPE_VIS_OFF == runner->ev.expect) && (!vis))) + { + runner->ev.response = runner->ev.expect; + elm_exit(); + } + +finish: + if ((name) || (text)) + { + ERR("errname:%s errmsg:%s\n", name, text); + } +} + +static void +_cb_signal_stack_changed(void *data, + const Eldbus_Message *msg) +{ + E_TC_Runner *runner = data; + const char *name = NULL, *text = NULL; + Eina_Bool res; + + res = eldbus_message_error_get(msg, &name, &text); + EINA_SAFETY_ON_FALSE_GOTO(res, finish); + + /* TODO */ + if ((E_TC_EVENT_TYPE_STACK_RAISE <= runner->ev.expect) && + (E_TC_EVENT_TYPE_STACK_BELOW >= runner->ev.expect)) + { + runner->ev.response = runner->ev.expect; + elm_exit(); + } + +finish: + if ((name) || (text)) + { + ERR("errname:%s errmsg:%s\n", name, text); + } +} + +static Eina_Bool +_ev_wait_timeout(void *data) +{ + E_TC_Runner *runner = data; + + runner->ev_expire_timer = NULL; + runner->ev.response = E_TC_EVENT_TYPE_TIMEOUT; + + elm_exit(); + + return ECORE_CALLBACK_DONE; +} + +Eina_Bool +e_tc_runner_req_win_register(E_TC_Runner *runner, + E_TC_Win *tw) +{ + Eldbus_Pending *p; + Eina_Bool accepted = EINA_FALSE; + + p = eldbus_proxy_call(runner->dbus.proxy, + "RegisterWindow", + _cb_method_window_register, + &accepted, + -1, + "u", + tw->native_win); + EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE); + + elm_run(); + + return accepted; +} + +Eina_Bool +e_tc_runner_req_win_deregister(E_TC_Runner *runner, + E_TC_Win *tw) +{ + Eldbus_Pending *p; + Eina_Bool allowed = EINA_FALSE; + + p = eldbus_proxy_call(runner->dbus.proxy, + "DeregisterWindow", + _cb_method_window_deregister, + &allowed, + -1, + "u", + tw->native_win); + EINA_SAFETY_ON_NULL_RETURN_VAL(p, EINA_FALSE); + + elm_run(); + + return allowed; +} + +Eina_List * +e_tc_runner_req_win_info_list_get(E_TC_Runner *runner) +{ + Eldbus_Pending *p; + Eina_List *list = NULL; + + p = eldbus_proxy_call(runner->dbus.proxy, + "GetClients", + _cb_method_win_info_list_get, + list, + -1, + ""); + EINA_SAFETY_ON_NULL_RETURN_VAL(p, NULL); + + elm_run(); + + return list; +} + +Eina_Bool +e_tc_runner_ev_wait(E_TC_Runner *runner, + E_TC_Event_Type ev) +{ + Eldbus_Signal_Handler *sh; + Eina_Bool res = EINA_FALSE; + + runner->ev.expect = ev; + runner->ev.response = E_TC_EVENT_TYPE_NONE; + + switch (ev) + { + case E_TC_EVENT_TYPE_VIS_ON: + case E_TC_EVENT_TYPE_VIS_OFF: + sh = eldbus_proxy_signal_handler_add(runner->dbus.proxy, + "ChangeVisibility", + _cb_signal_vis_changed, + runner); + EINA_SAFETY_ON_NULL_GOTO(finish); + break; + + case E_TC_EVENT_TYPE_STACK_RAISE: + case E_TC_EVENT_TYPE_STACK_LOWER: + case E_TC_EVENT_TYPE_STACK_ABOVE: + case E_TC_EVENT_TYPE_STACK_BELOW: + sh = eldbus_proxy_signal_handler_add(runner->dbus.proxy, + "Restack", + _cb_signal_stack_changed, + runner); + EINA_SAFETY_ON_NULL_GOTO(finish); + break; + + default: + EINA_SAFETY_ON_NULL_GOTO(finish); + break; + } + + runner->ev.expire_timer = ecore_timer_add(2.0, _ev_wait_timeout, runner); + + elm_run(); + + if (runner->ev_expire_timer) + { + ecore_timer_del(runner->ev.expire_timer); + runner->ev.expire_timer = NULL; + } + + eldbus_signal_handler_del(sh); + + res = (runner->ev.response == runner->ev.expect); + +finish: + runner->ev.expect = E_TC_EVENT_TYPE_NONE; + runner->ev.response = E_TC_EVENT_TYPE_NONE; + + return res; +} + +E_TC_Win * +e_tc_win_add(E_TC_Win *parent, + Elm_Win_Type type, + Eina_Bool alpha, + const char *name, + int x, int y, + int w, int h, + int layer) +{ + E_TC_Win *tw = NULL; + Evas_Object *elm_win = NULL, *bg = NULL; + Evas_Object *p_elm_win = NULL; + + if (parent) p_elm_win = tw->elm_win; + + elm_win = elm_win_add(p_elm_win, name, ELM_WIN_BASIC); + EINA_SAFETY_ON_NULL_GOTO(elm_win, err); + + if (alpha) elm_win_alpha_set(elm_win, EINA_TRUE); + + elm_win_title_set(elm_win, name); + elm_win_autodel_set(elm_win, EINA_FALSE); + + bg = elm_bg_add(elm_win); + evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_win_resize_object_add(elm_win, bg); + elm_bg_color_set(bg, 0, 120, 100); + evas_object_show(bg); + + tw = E_NEW(E_TC_Win, 1); + EINA_SAFETY_ON_NULL_RETURN_VAL(tw, NULL); + + tw->elm_win = elm_win; + tw->native_win = elm_win_xwindow_get(elm_win); // TODO: wayland + tw->name = eina_stringshare_add(name); + tw->x = x; + tw->y = y; + tw->w = w; + tw->h = h; + tw->layer = layer; + tw->alpha = alpha; + + return tw; + +err: + evas_object_del(elm_win); + E_FREE(tw); + + return NULL; +} + +E_TC_Win * +e_tc_win_info_add(Ecore_Window native_win, + Eina_Bool alpha, + const char *name, + int x, int y, + int w, int h, + int layer) +{ + E_TC_Win *tw = NULL; + + tw = E_NEW(E_TC_Win, 1); + EINA_SAFETY_ON_NULL_RETURN_VAL(tw, NULL); + + tw->elm_win = NULL; + tw->native_win = native_win; + tw->name = eina_stringshare_add(name); + tw->x = x; + tw->y = y; + tw->w = w; + tw->h = h; + tw->layer = layer; + tw->alpha = alpha; + + return tw; + +err: + E_FREE(tw); + return NULL; +} + +void +e_tc_win_del(E_TC_Win *tw) +{ + EINA_SAFETY_ON_NULL_RETURN(tw); + + if (tw->elm_win) + evas_object_del(tw->elm_win); + + if (tw->name) + eina_stringshare_del(tw->name); + + E_FREE(tw); +} + +void +e_tc_win_geom_update(E_TC_Win *tw) +{ + evas_object_move(tw->elm_win, tw->x, tw->y); + evas_object_resize(tw->elm_win, tw->w, tw->h); +} + +void +e_tc_win_show(E_TC_Win *tw) +{ + evas_object_show(tw->elm_win); +} + +void +e_tc_win_hide(E_TC_Win *tw) +{ + evas_object_hide(tw->elm_win); +} + +void +e_tc_win_stack_change(E_TC_Win *tw, E_TC_Win *sibling, Eina_Bool above) +{ + /* TODO */ + if (sibling) + { + if (above) + { + ; // stack above: window is placed above sibling window. + } + else + { + ; // stack below: window is placed below sibling window. + } + } + else + { + if (above) + { + ; // raise: window is placed at the top of stack. + } + else + { + ; // lower: window is placed at the bottom of stack. + } + } +} + +static E_TC * +_e_tc_add(unsigned int num, + const char *name, + Eina_Bool (*func)(E_TC*), + Eina_Bool expect, + E_TC_Runner *runner) +{ + E_TC *tc; + + tc = E_NEW(E_TC, 1); + + tc->num = num; + tc->name = name; + tc->func = func; + tc->expect = expect; + tc->runner = runner; + + runner->tc_list = eina_list_append(runner->tc_list, tc); + + return tc; +} + +#undef TC_ADD +#define TC_ADD(num, name, func, expect, runner) _e_tc_add(num, name, func, expect, runner) + +static void +_e_tc_runner_init(E_TC_Runner *runner) +{ +#undef T_FUNC +#define T_FUNC(num_, test_) tc_000##num_##_##test_ + /* [0000 - 0099] test runner verification */ + TC_ADD( 0, "Base: Pass", T_FUNC( 0, base_pass ), 1); + TC_ADD( 1, "Base: Fail", T_FUNC( 1, base_fail ), 0); +#undef T_FUNC +#define T_FUNC(num_, test_) tc_00##num_##_##test_ + TC_ADD( 10, "DBus: Introspect", T_FUNC( 10, introspect ), 1); + TC_ADD( 11, "DBus: Window register", T_FUNC( 11, win_register ), 1); +#undef T_FUNC +#define T_FUNC(num_, test_) tc_0##num_##_##test_ + /* [0100 - 0199] window base operation */ + TC_ADD( 100, "Basic window: Show", T_FUNC( 100, win_show ), 1); + TC_ADD( 101, "Basic window: Stack", T_FUNC( 101, win_stack ), 1); + TC_ADD( 110, "Alpha window: Show", T_FUNC( 110, alpha_win_show ), 1); + TC_ADD( 111, "Alpha window: Stack", T_FUNC( 111, alpha_win_stack ), 1); + /* [0200 - 0299] transient for */ + TC_ADD( 200, "Transient for: Basic", T_FUNC( 200, transient_for_basic ), 1); + TC_ADD( 201, "Transient for: Raise", T_FUNC( 201, transient_for_raise ), 1); + TC_ADD( 202, "Transient for: Lower", T_FUNC( 202, transient_for_lower ), 1); + TC_ADD( 203, "Transient for: Stack above", T_FUNC( 203, transient_for_stack_above), 1); + TC_ADD( 204, "Transient for: Stack below", T_FUNC( 204, transient_for_stack_below), 1); + /* [0300 - 0399] notification */ + /* TODO */ +#undef T_FUNC +} + +static void +_e_tc_runner_shutdown(E_TC_Main_Data *data) +{ + E_TC *tc; + + EINA_LIST_FREE(data->tc_list, tc) + { + E_FREE(tc); + } +} + +static void +_e_tc_runner_run(E_TC_Main_Data *data) +{ + Eina_List *l; + E_TC *tc; + Eina_Bool pass; + + EINA_LIST_FOREACH(data->tc_list, l, tc) + { + pass = tc->test(tc); + tc->passed = (pass == tc->expect); + + printf("TEST \"%s\" : %s\n", + tc->name, + tc->passed ? "PASS" : "FAIL"); + + if ((!tc->passed) && (tc->is_stopper)) + break; + } +} + +static void +_e_tc_runner_result(E_TC_Main_Data *data) +{ + Eina_Strbuf *buf; + Eina_List *l, *ll; + E_TC *tc, *in_tc; + int pass_case = 0; + int fail_case = 0; + int total = 0; + + if (!(buf = eina_strbuf_new())) return; + + eina_strbuf_append(buf, "\n\n"); + eina_strbuf_append(buf, "==============================================\n"); + eina_strbuf_append(buf, "TEST CASE RESULT\n"); + eina_strbuf_append(buf, "==============================================\n"); + + EINA_LIST_FOREACH(data->tc_list, l, tc) + { + eina_strbuf_append_printf(buf, "[%04d] TEST \"%-25.25s\" : %s\n", + tc->num, tc->name, tc->passed ? "PASS" : "FAIL"); + + total++; + tc->passed? pass_case++ : fail_case++; + + if (!tc->passed) + { + eina_strbuf_append_printf(buf, "\n!!Test Case failed at \"%s\"\n", tc->name); + break; + } + } + + eina_strbuf_append(buf, "==============================================\n"); + eina_strbuf_append_printf(buf, "TOTAL: %4d Case\n", total); + eina_strbuf_append_printf(buf, "PASS : %4d Case\n", pass_case); + eina_strbuf_append_printf(buf, "FAIL : %4d Case\n", fail_case); + eina_strbuf_append(buf, "==============================================\n"); + + printf("%s", eina_strbuf_string_get(buf)); +} + +EAPI_MAIN int +elm_main(int argc EINA_UNUSED, + char **argv EINA_UNUSED) +{ + E_TC_Runner *runner = NULL; + E_TC *tc; + Eina_List *l; + int res; + + runner = E_NEW(E_TC_Runner, 1); + EINA_SAFETY_ON_NULL_GOTO(runner, err); + + _log_dom = eina_log_domain_register("e-tc", EINA_COLOR_BLUE); + if (_log_dom < 0) + { + ERR("Can't register e-tc log domain."); + goto err; + } + + res = eldbus_init(); + EINA_SAFETY_ON_FALSE_GOTO((res > 0), err); + + runner->dbus.conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM); + if (!runner->dbus.conn) + { + ERR("Can't get dbus connection."); + goto err; + } + + runner->dbus.obj = eldbus_object_get(runner->dbus.conn, + "org.enlightenment.wm", + "/org/enlightenment/wm"); + if (!runner->dbus.obj) + { + ERR("Can't get dbus object."); + goto err; + } + + runner->dbus.proxy = eldbus_proxy_get(runner->dbus.obj, + "org.enlightenment.wm.Test"); + if (!runner->dbus.proxy) + { + ERR("Can't get dbus proxy."); + goto err; + } + + _e_tc_runner_init(runner); + _e_tc_runner_run(runner); + _e_tc_runner_result(runner); + _e_tc_runner_shutdown(runner); + + eldbus_proxy_unref(runner->dbus.proxy); + eldbus_object_unref(runner->dbus.obj); + eldbus_connection_unref(runner->dbus.conn); + eldbus_shutdown(); + eina_log_domain_unregister(_log_dom); + + E_FREE(runner); + return 0; + +err: + E_FREE(runner); + return -1; +} +ELM_MAIN() diff --git a/src/e_tc_main.h b/src/e_tc_main.h new file mode 100644 index 0000000..552189c --- /dev/null +++ b/src/e_tc_main.h @@ -0,0 +1,146 @@ +#ifndef E_TC_MAIN_H +#define E_TC_MAIN_H + +#include +#include + +extern int _log_dom; + +#ifdef ERR +# undef ERR +#endif +#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__) + +#ifdef DBG +# undef DBG +#endif +#define DBG(...) EINA_LOG_DOM_DBG(_log_dom, __VA_ARGS__) + +#ifdef INF +# undef INF +#endif +#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__) + +#ifdef WRN +# undef WRN +#endif +#define WRN(...) EINA_LOG_DOM_WARN(_log_dom, __VA_ARGS__) + +#ifdef CRI +# undef CRI +#endif +#define CRI(...) EINA_LOG_DOM_CRIT(_log_dom, __VA_ARGS__) + +#ifdef E_NEW +# undef E_NEW +#endif +# define E_NEW(s, n) (s *)calloc(n, sizeof(s)) + +#ifdef E_FREE +# undef E_FREE +#endif +# define E_FREE(p) do { free(p); p = NULL; } while (0) + +#ifdef E_FREE_LIST +# undef E_FREE_LIST +#endif +# define E_FREE_LIST(list, free) \ + do \ + { \ + void *_tmp_; \ + EINA_LIST_FREE(list, _tmp_) \ + { \ + free(_tmp_); \ + } \ + } \ + while (0) + +typedef enum _E_TC_Event_Type +{ + E_TC_EVENT_TYPE_NONE, + E_TC_EVENT_TYPE_TIMEOUT, + E_TC_EVENT_TYPE_VIS_ON, + E_TC_EVENT_TYPE_VIS_OFF, + E_TC_EVENT_TYPE_STACK_RAISE, + E_TC_EVENT_TYPE_STACK_LOWER, + E_TC_EVENT_TYPE_STACK_ABOVE, + E_TC_EVENT_TYPE_STACK_BELOW +} E_TC_Event_Type; + +typedef struct _E_TC_Runner E_TC_Runner; +typedef struct _E_TC_Win E_TC_Win; +typedef struct _E_TC E_TC; +typedef struct _E_TC_Data E_TC_Data; + +struct _E_TC_Runner +{ + Eina_List *tc_list; // test suite + + struct + { + Ecore_Timer *expire_timer; + E_TC_Event_Type expect; + E_TC_Event_Type response; + } ev; + + struct + { + Eldbus_Connection *conn; + Eldbus_Proxy *proxy; + Eldbus_Object *obj; + } dbus; +}; + +struct _E_TC_Win +{ + Evas_Object *elm_win; // elm_win evas object + Ecore_Window native_win; // native window id + const char *name; // name of client window + int x, y, w, h; // geometry + int layer; // value of E_Layer + int vis; // visibility + int alpha; // alpha window +}; + +struct _E_TC +{ + const char *name; + unsigned int num; + Eina_Bool (*func) (E_TC *tc); + Eina_Bool passed; + Eina_Bool expect; + E_TC_Runner *runner; + E_TC_Data *data; +}; + +Eina_Bool e_tc_runner_req_win_register(E_TC_Runner *runner, E_TC_Win *tw); +Eina_Bool e_tc_runner_req_win_deregister(E_TC_Runner *runner, E_TC_Win *tw); +Eina_List *e_tc_runner_req_win_info_list_get(E_TC_Runner *runner); +Eina_Bool e_tc_runner_ev_wait(E_TC_Runner *runner, E_TC_Event_Type ev); + +E_TC_Win *e_tc_win_add(E_TC_Win *parent, Elm_Win_Type type, Eina_Bool alpha, const char *name, int x, int y, int w, int h, int layer); +E_TC_Win *e_tc_win_info_add(Ecore_Window native_win, Eina_Bool alpha, const char *name, int x, int y, int w, int h, int layer); +void e_tc_win_del(E_TC_Win *tw); +void e_tc_win_geom_update(E_TC_Win *tw); +void e_tc_win_show(E_TC_Win *tw); +void e_tc_win_hide(E_TC_Win *tw); +void e_tc_win_stack_change(E_TC_Win *tw, E_TC_Win *sibling, Eina_Bool above); + +/* test cases */ +Eina_Bool tc_0000_base_pass(E_TC *tc); +Eina_Bool tc_0001_base_fail(E_TC *tc); +Eina_Bool tc_0010_introspect(E_TC *tc); +Eina_Bool tc_0011_win_register(E_TC *tc); + +Eina_Bool tc_0100_win_show(E_TC *tc); +Eina_Bool tc_0101_win_stack(E_TC *tc); +Eina_Bool tc_0110_alpha_win_show(E_TC *tc); +Eina_Bool tc_0111_alpha_win_stack(E_TC *tc); + +Eina_Bool tc_0200_transient_for_basic(E_TC *tc); +Eina_Bool tc_0201_transient_for_raise(E_TC *tc); +Eina_Bool tc_0202_transient_for_lower(E_TC *tc); +Eina_Bool tc_0203_transient_for_stack_above(E_TC *tc); +Eina_Bool tc_0204_transient_for_stack_below(E_TC *tc); + +#endif diff --git a/src/e_test_case_main.c b/src/e_test_case_main.c deleted file mode 100644 index 7ce17f3..0000000 --- a/src/e_test_case_main.c +++ /dev/null @@ -1,262 +0,0 @@ -#include "e_test_case_main.h" - -#define ADD_TEST_CASE(type_, num_, test_, name_, expect_, is_stopper_) \ - tc = _e_test_case_add(type_, num_, name_, test_, expect_, is_stopper_) -#define ADD_INNER_TCS(type_, num_, test_, name_, expect_, is_stopper_) \ - _e_test_case_inner_add(tc, type_, num_, name_, test_, expect_, is_stopper_) - -Eldbus_Connection *dbus_conn; -Eldbus_Proxy *dbus_proxy; -Eldbus_Object *dbus_obj; - -static Eina_List *tcs = NULL; - -int _e_tizen_testcase_log_dom = -1; - -static void -_e_test_case_inner_add(E_Test_Case* gtc, - E_Test_Case_Type type, - unsigned int num, const char *name, - Eina_Bool (*test)(E_Test_Case*), - Eina_Bool expect, Eina_Bool is_stopper) -{ - E_Test_Case *tc; - - tc = E_NEW(E_Test_Case, 1); - tc->type = type; - tc->num = num, - tc->name = name; - tc->test = test; - tc->expect = expect; - tc->is_stopper = is_stopper; - - gtc->inner_tcs = eina_list_append(gtc->inner_tcs, tc); -} - -static E_Test_Case * -_e_test_case_add(E_Test_Case_Type type, - unsigned int num, const char *name, - Eina_Bool (*test)(E_Test_Case*), - Eina_Bool expect, Eina_Bool is_stopper) -{ - E_Test_Case *tc; - - tc = E_NEW(E_Test_Case, 1); - tc->type = type; - tc->num = num; - tc->name = name; - tc->test = test; - tc->expect = expect; - tc->is_stopper = is_stopper; - - tcs = eina_list_append(tcs, tc); - - return tc; -} - -static void -_e_test_case_setup(void) -{ - E_Test_Case *tc = NULL; - - /* [0000 - 0009] E_TEST_CASE_TYPE_BASE */ -#undef T -#define T E_TEST_CASE_TYPE_BASE -#undef T_FUNC -#define T_FUNC(num_, test_) test_case_000##num_##_##test_ - ADD_TEST_CASE(T, 0, T_FUNC(0, easy_pass), "Easy Pass", 1, 1); - ADD_TEST_CASE(T, 0, T_FUNC(0, easy_fail), "Easy Fail", 0, 1); - ADD_TEST_CASE(T, 1, T_FUNC(1, introspect), "Introspect", 1, 1); - ADD_TEST_CASE(T, 2, T_FUNC(2, deregister), "(De)Register", 1, 1); - - /* [0010 - 0099] */ -#undef T_FUNC -#define T_FUNC(num_, test_) test_case_00##num_##_##test_ - - /* [0100 - 0199] E_TEST_CASE_TYPE_WIN */ -#undef T -#define T E_TEST_CASE_TYPE_WIN -#undef T_FUNC -#define T_FUNC(num_, test_) test_case_0##num_##_##test_ - ADD_TEST_CASE(T, 100, T_FUNC(100, basic), "Basic", 1, 0); - ADD_INNER_TCS(T, 101, T_FUNC(101, basic_stack), "Basic Stack", 1, 0); - - ADD_TEST_CASE(T, 110, T_FUNC(110, transient_for), "Transient For", 1, 0); - ADD_INNER_TCS(T, 111, T_FUNC(111, transient_for_raise), "Transient For Raise", 1, 0); - ADD_INNER_TCS(T, 112, T_FUNC(112, transient_for_lower), "Transient For Lower", 1, 0); - ADD_INNER_TCS(T, 113, T_FUNC(113, transient_for_stack_above), "Transient For Stack Above", 1, 0); - ADD_INNER_TCS(T, 114, T_FUNC(114, transient_for_stack_below), "Transient For STack Below", 1, 0); - - ADD_TEST_CASE(T, 120, T_FUNC(120, notification_level), "Noti Level", 1, 0); - ADD_INNER_TCS(T, 121, T_FUNC(121, notification_level_1), "Noti Level 1", 1, 0); - ADD_INNER_TCS(T, 122, T_FUNC(122, notification_level_2), "Noti Level 2", 1, 0); - ADD_INNER_TCS(T, 123, T_FUNC(123, notification_level_3), "Noti Level 3", 1, 0); - ADD_INNER_TCS(T, 124, T_FUNC(124, notification_level_change), "Noti Level Change", 1, 0); - - /* [0200 - 0299] E_TEST_CASE_TYPE_WIN_ALPHA */ -#undef T -#define T E_TEST_CASE_TYPE_WIN_ALPHA - - /* [0300 - 0999] E_TEST_CASE_TYPE_NONE */ -#undef T -#define T E_TEST_CASE_TYPE_NONE - - /* [1000 - 9999] */ -#undef T_FUNC -#define T_FUNC(num_, test_) test_case_##num_##_##test_ - -#undef T -#undef T_FUNC -} - -static void -_e_test_case_result_print(void) -{ - Eina_Strbuf *buf; - Eina_List *l, *ll; - E_Test_Case *tc, *in_tc; - int pass_case = 0; - int fail_case = 0; - int total = 0; - - if (!(buf = eina_strbuf_new())) return; - - eina_strbuf_append(buf, "\n\n==============================================\n"); - eina_strbuf_append(buf, "TEST CASE RESULT\n"); - eina_strbuf_append(buf, "==============================================\n"); - - EINA_LIST_FOREACH(tcs, l, tc) - { - eina_strbuf_append_printf(buf, - "[%04d] TEST \"%-25.25s\" : %s\n", - tc->num, - tc->name, tc->inner_tcs? "-" : tc->passed? "PASS":"FAIL"); - - if (tc->inner_tcs) - { - EINA_LIST_FOREACH(tc->inner_tcs, ll, in_tc) - { - eina_strbuf_append_printf(buf, - "[%04d] TEST \"%-25.25s\" : %s\n", - in_tc->num, - in_tc->name, in_tc->passed? "PASS":"FAIL"); - total ++; - in_tc->passed? pass_case++ : fail_case++; - if ((in_tc->is_stopper) && (!tc->passed)) - break; - } - } - else - { - total ++; - tc->passed? pass_case++ : fail_case++; - } - - if ((tc->is_stopper) && (!tc->passed)) - { - eina_strbuf_append_printf(buf, "\n!!Test Case failed at \"%s\"\n", tc->name); - break; - } - } - - eina_strbuf_append(buf, "==============================================\n"); - eina_strbuf_append_printf(buf, "TOTAL: %4d Case\n", total); - eina_strbuf_append_printf(buf, "PASS : %4d Case\n", pass_case); - eina_strbuf_append_printf(buf, "FAIL : %4d Case\n", fail_case); - eina_strbuf_append(buf, "==============================================\n"); - - printf("%s", eina_strbuf_string_get(buf)); -} - -EAPI Eina_Bool -e_test_case_inner_do(E_Test_Case *tc) -{ - E_Test_Case *_tc; - Eina_List *l; - Eina_Bool pass; - - pass = !!tc->inner_tcs; - - EINA_LIST_FOREACH(tc->inner_tcs, l, _tc) - { - _tc->passed = (_tc->test(_tc) == _tc->expect); - printf("TEST \"%s\" : %s\n", _tc->name, _tc->passed?"PASS":"FAIL"); - pass = pass && _tc->passed; - - if ((!_tc->passed) && (_tc->is_stopper)) - { - tc->is_stopper = EINA_TRUE; - break; - } - } - - return pass; -} - -EAPI Eina_Bool -e_test_case_do(E_Test_Case *tc) -{ - Eina_Bool pass = EINA_FALSE; - - pass = tc->test(tc); - tc->passed = (pass == tc->expect); - - printf("TEST \"%s\" : %s\n", tc->name, tc->passed?"PASS":"FAIL"); - - if ((!tc->passed) && (tc->is_stopper)) - return EINA_FALSE; - - return EINA_TRUE; -} - -EAPI_MAIN int -elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED) -{ - E_Test_Case *tc; - Eina_List *l; - - _e_tizen_testcase_log_dom = eina_log_domain_register ("e_tizen-testcase", EINA_COLOR_BLUE); - if(_e_tizen_testcase_log_dom < 0) - { - ERR("Impossible to create a log domain for the ecore input module."); - return -1; - } - - if (!eldbus_init()) return -1; - - /* connect to dbus */ - dbus_conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM); - dbus_obj = eldbus_object_get(dbus_conn, BUS, PATH); - dbus_proxy = eldbus_proxy_get(dbus_obj, INTERFACE); - - /* setup testcase list */ - _e_test_case_setup(); - - /* do test */ - EINA_LIST_FOREACH(tcs, l, tc) - { - if (!e_test_case_do(tc)) break; - } - - /* print test result */ - _e_test_case_result_print(); - - /* shutdown */ - EINA_LIST_FREE(tcs, tc) - { - E_FREE_LIST(tc->inner_tcs, free); - E_FREE(tc); - } - - eina_log_domain_unregister(_e_tizen_testcase_log_dom); - _e_tizen_testcase_log_dom = -1; - - eldbus_proxy_unref(dbus_proxy); - eldbus_object_unref(dbus_obj); - eldbus_connection_unref(dbus_conn); - - eldbus_shutdown(); - - return 0; -} -ELM_MAIN() diff --git a/src/e_test_case_main.h b/src/e_test_case_main.h deleted file mode 100644 index 7343821..0000000 --- a/src/e_test_case_main.h +++ /dev/null @@ -1,175 +0,0 @@ -#ifndef E_MOD_TEST_CASE_H -#define E_MOD_TEST_CASE_H - -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include -# include - -extern int _e_tizen_testcase_log_dom; - -#ifdef ERR -# undef ERR -#endif -#define ERR(...) EINA_LOG_DOM_ERR(_e_tizen_testcase_log_dom, __VA_ARGS__) - -#ifdef DBG -# undef DBG -#endif -#define DBG(...) EINA_LOG_DOM_DBG(_e_tizen_testcase_log_dom, __VA_ARGS__) - -#ifdef INF -# undef INF -#endif -#define INF(...) EINA_LOG_DOM_INFO(_e_tizen_testcase_log_dom, __VA_ARGS__) - -#ifdef WRN -# undef WRN -#endif -#define WRN(...) EINA_LOG_DOM_WARN(_e_tizen_testcase_log_dom, __VA_ARGS__) - -#ifdef CRI -# undef CRI -#endif -#define CRI(...) EINA_LOG_DOM_CRIT(_e_tizen_testcase_log_dom, __VA_ARGS__) - -#ifdef E_REALLOC -# undef E_REALLOC -#endif -# define E_REALLOC(p, s, n) p = (s *)realloc(p, sizeof(s) * n) - -#ifdef E_NEW -# undef E_NEW -#endif -# define E_NEW(s, n) (s *)calloc(n, sizeof(s)) - -#ifdef E_NEW_RAW -# undef E_NEW_RAW -#endif -# define E_NEW_RAW(s, n) (s *)malloc(n * sizeof(s)) - -#ifdef E_FREE -# undef E_FREE -#endif -# define E_FREE(p) do { free(p); p = NULL; } while (0) - -#ifdef E_FREE_LIST -# undef E_FREE_LIST -#endif -# define E_FREE_LIST(list, free) \ - do \ - { \ - void *_tmp_; \ - EINA_LIST_FREE(list, _tmp_) \ - { \ - free(_tmp_); \ - } \ - } \ - while (0) - -extern Eldbus_Connection *dbus_conn; -extern Eldbus_Proxy *dbus_proxy; -extern Eldbus_Object *dbus_obj; - -#define BUS "org.enlightenment.wm" -#define PATH "/org/enlightenment/wm" -#define INTERFACE "org.enlightenment.wm.Test" - -typedef enum _E_Test_Case_Type -{ - E_TEST_CASE_TYPE_BASE = 0, - E_TEST_CASE_TYPE_WIN = 100, - E_TEST_CASE_TYPE_WIN_ALPHA = 200, - E_TEST_CASE_TYPE_NONE = 300 -} E_Test_Case_Type; - -typedef struct _E_TC_Client E_TC_Client; -typedef struct _E_TC_Data E_TC_Data; -typedef struct _E_Test_Case E_Test_Case; - -struct _E_Test_Case -{ - const char *name; - E_Test_Case_Type type; - unsigned int num; - - Eina_Bool (*test) (E_Test_Case *tc); - - Eina_Bool passed; - Eina_Bool expect; - Eina_Bool is_stopper; - - Eina_List *inner_tcs; -}; - -struct _E_TC_Data -{ - E_TC_Client *client; - Eina_List *clients; -}; - -struct _E_TC_Client -{ - Evas_Object *obj; - - const char *name; - int x, y, w, h; - int layer; - int visible; - int argb; - Ecore_Window win; -}; - -EAPI Eina_Bool e_test_case_inner_do(E_Test_Case *tc); -EAPI Eina_Bool e_test_case_do(E_Test_Case *tc); - -/* test cases */ -/* 0000 - 0099 */ -//force true/false -Eina_Bool test_case_0000_easy_pass(E_Test_Case *tc); -Eina_Bool test_case_0000_easy_fail(E_Test_Case *tc); -//dbus check -Eina_Bool test_case_0001_introspect(E_Test_Case *tc); -Eina_Bool test_case_0002_deregister(E_Test_Case *tc); - -/* 0100 - 0199 */ -//normal state -Eina_Bool test_case_0100_basic(E_Test_Case *tc); -Eina_Bool test_case_0101_basic_stack(E_Test_Case *tc); - -//transient_for -Eina_Bool test_case_0110_transient_for(E_Test_Case *tc); -Eina_Bool test_case_0111_transient_for_raise(E_Test_Case *tc); -Eina_Bool test_case_0112_transient_for_lower(E_Test_Case *tc); -Eina_Bool test_case_0113_transient_for_stack_above(E_Test_Case *tc); -Eina_Bool test_case_0114_transient_for_stack_below(E_Test_Case *tc); - -//notification_level -Eina_Bool test_case_0120_notification_level(E_Test_Case *tc); -Eina_Bool test_case_0121_notification_level_1(E_Test_Case *tc); -Eina_Bool test_case_0122_notification_level_2(E_Test_Case *tc); -Eina_Bool test_case_0123_notification_level_3(E_Test_Case *tc); -Eina_Bool test_case_0124_notification_level_change(E_Test_Case *tc); - -/* 0200 - 0299 */ -/* 0300 - 9999 */ - -/* end of test cases */ - -#endif diff --git a/src/e_test_case_util.c b/src/e_test_case_util.c deleted file mode 100644 index 23f9434..0000000 --- a/src/e_test_case_util.c +++ /dev/null @@ -1,238 +0,0 @@ -#include "e_test_case_main.h" -#include "e_test_case_util.h" - -static Ecore_Timer *vis_exit_timer = NULL; - -static void -_method_cb_get_clients(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) -{ - const char *errname, *errmsg; - Eldbus_Message_Iter *array_of_ec, *struct_of_ec; - Ecore_Window target_win = 0; - E_TC_Data *tc_data = data; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s", errname, errmsg); - elm_exit(); - return; - } - - if (!eldbus_message_arguments_get(msg, "ua(usiiiiibb)", &target_win, &array_of_ec)) - { - ERR("Error on eldbus_message_arguments_get()\n"); - elm_exit(); - return; - } - - if (tc_data->clients) - tc_data->clients = eina_list_free(tc_data->clients); - - while (eldbus_message_iter_get_and_next(array_of_ec, 'r', &struct_of_ec)) - { - const char *name; - int x, y, w, h, layer; - Eina_Bool visible, argb; - Ecore_Window win; - E_TC_Client *client = NULL; - - if (!eldbus_message_iter_arguments_get(struct_of_ec, "usiiiiibb", &win, &name, &x, &y, &w, &h, &layer, &visible, &argb)) - { - WRN("Error on eldbus_message_arguments_get()\n"); - continue; - } - - client = E_NEW(E_TC_Client, 1); - client->x = x; - client->y = y; - client->w = w; - client->h = h; - client->layer = layer; - client->win = win; - client->name = eina_stringshare_add(name); - tc_data->clients = eina_list_append(tc_data->clients, client); - } - - elm_exit(); -} - -static void -_method_cb_register_window(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) -{ - const char *errname, *errmsg; - Eina_Bool *accepted = data; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s\n", errname, errmsg); - } - - if (!eldbus_message_arguments_get(msg, "b", accepted)) - { - ERR("Error on eldbus_message_arguments_get()\n"); - } - - elm_exit(); -} - -static void -_method_cb_deregister_window(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) -{ - const char *errname, *errmsg; - Eina_Bool *allowed = data; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s\n", errname, errmsg); - } - - if (!eldbus_message_arguments_get(msg, "b", allowed)) - { - ERR("Error on eldbus_message_arguments_get()\n"); - } - - elm_exit(); -} - -static Eina_Bool -_timeout_wait_change_visibility(void *data) -{ - E_Test_Case_Wait_Vis_Type *type = data; - - *type = E_TEST_CASE_WAIT_VIS_TYPE_TIMEOUT; - vis_exit_timer = NULL; - elm_exit(); - - return ECORE_CALLBACK_DONE; -} - -static void -_signal_cb_change_visibility(void *data, const Eldbus_Message *msg) -{ - const char *errname, *errmsg; - E_Test_Case_Wait_Vis_Type *type = data; - int vis = 0; - Ecore_Window id; - - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s", errname, errmsg); - } - - if (!eldbus_message_arguments_get(msg, "ub", &id, &vis)) - { - ERR("Error on eldbus_message_arguments_get()\n"); - } - - if ((*type == E_TEST_CASE_WAIT_VIS_TYPE_CHANGED) || - ((*type == E_TEST_CASE_WAIT_VIS_TYPE_ON) && (vis)) || - ((*type == E_TEST_CASE_WAIT_VIS_TYPE_OFF) && (!vis))) - elm_exit(); -} - -static void -_signal_cb_restack(void *data EINA_UNUSED, const Eldbus_Message *msg) -{ - const char *errname, *errmsg; - if (eldbus_message_error_get(msg, &errname, &errmsg)) - { - ERR("%s %s", errname, errmsg); - } - - elm_exit(); -} - -EAPI void -e_test_case_util_get_clients(E_TC_Data *tc_data) -{ - if (!eldbus_proxy_call(dbus_proxy, "GetClients", - _method_cb_get_clients, tc_data, -1, "")) - return; - - elm_run(); -} - -EAPI Eina_Bool -e_test_case_util_register_window(Ecore_Window win) -{ - Eina_Bool accepted = EINA_FALSE; - - if (!eldbus_proxy_call(dbus_proxy, - "RegisterWindow", _method_cb_register_window, - &accepted, -1, "u", win)) - return EINA_FALSE; - - elm_run(); - - return accepted; -} - -EAPI Eina_Bool -e_test_case_util_deregister_window(Ecore_Window win) -{ - Eina_Bool allowed = EINA_FALSE; - - if (!eldbus_proxy_call(dbus_proxy, - "DeregisterWindow", _method_cb_deregister_window, - &allowed, -1, "u", win)) - return EINA_FALSE; - - elm_run(); - - return allowed; -} - -EAPI Eina_Bool -e_test_case_util_wait_visibility_change(E_Test_Case_Wait_Vis_Type expect) -{ - Eldbus_Signal_Handler *sh; - E_Test_Case_Wait_Vis_Type type; - - type = expect; - if (!(sh = eldbus_proxy_signal_handler_add(dbus_proxy, - "ChangeVisibility", - _signal_cb_change_visibility, - &type))) - return EINA_FALSE; - - vis_exit_timer = ecore_timer_add(2.0, _timeout_wait_change_visibility, &type); - elm_run(); - - if (vis_exit_timer) - { - ecore_timer_del(vis_exit_timer); - vis_exit_timer = NULL; - } - eldbus_signal_handler_del(sh); - - return type == expect; -} - -EAPI Eina_Bool -e_test_case_util_change_stack(Ecore_Window target, Ecore_Window pic, int type) -{ - if (eldbus_proxy_call(dbus_proxy, "ChangeStack", NULL, - NULL, -1, "uiu", target, type, pic)) - return EINA_FALSE; - - return EINA_TRUE; -} - -EAPI Eina_Bool -e_test_case_util_wait_restack(void) -{ - Eldbus_Signal_Handler *sh; - - if (!(sh = eldbus_proxy_signal_handler_add(dbus_proxy, - "Restack", - _signal_cb_restack, - NULL))) - return EINA_FALSE; - - elm_run(); - - eldbus_signal_handler_del(sh); - sh = NULL; - - return EINA_TRUE; -} diff --git a/src/e_test_case_util.h b/src/e_test_case_util.h deleted file mode 100644 index 9b2224d..0000000 --- a/src/e_test_case_util.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef E_TEST_CASE_UTIL_H -#define E_TEST_CASE_UTIL_H - -typedef enum _E_Test_Case_Stack_Type -{ - E_TEST_CASE_STACK_TYPE_RAISE, - E_TEST_CASE_STACK_TYPE_LOWER, - E_TEST_CASE_STACK_TYPE_ABOVE, - E_TEST_CASE_STACK_TYPE_BELOW -} E_Test_Case_Stack_Type; - -typedef enum _E_Test_Case_Wait_Vis_Type -{ - E_TEST_CASE_WAIT_VIS_TYPE_TIMEOUT, - E_TEST_CASE_WAIT_VIS_TYPE_CHANGED, - E_TEST_CASE_WAIT_VIS_TYPE_ON, - E_TEST_CASE_WAIT_VIS_TYPE_OFF -} E_Test_Case_Wait_Vis_Type; - -EAPI void e_test_case_util_get_clients(E_TC_Data *tc_data); -EAPI Eina_Bool e_test_case_util_register_window(Ecore_Window win); -EAPI Eina_Bool e_test_case_util_deregister_window(Ecore_Window win); -EAPI Eina_Bool e_test_case_util_wait_visibility_change(E_Test_Case_Wait_Vis_Type expect); -EAPI Eina_Bool e_test_case_util_change_stack(Ecore_Window target, Ecore_Window pic, int type); -EAPI Eina_Bool e_test_case_util_wait_restack(void); - -#endif