+++ /dev/null
-#include <tzsh_screensaver_manager_service.h>
-#include <tzsh_screensaver_service.h>
-#include "e_test_runner.h"
-
-/* Name:
- * [0400] screensaver basic
- * Description:
- * Check screensaver type window that is shown on the notification layer.
- * Steps:
- * 01. Create an elm basic window
- * 02. Set elm window to be screensaver type using tzsh
- * 03. Show window
- * 04. Check window stack
- * Expected results:
- * A window is shown on the notification layer.
- */
-Eina_Bool
-tc_0400_scrsaver_basic(E_TC *tc)
-{
- Eina_Bool res = EINA_FALSE;
- Eina_List *l = NULL, *ll = NULL;
- E_TC_Win *tw = NULL, *tw2 = NULL;
-
- tzsh_h tzsh = NULL;
- tzsh_window tz_win = 0x0;
- tzsh_screensaver_service_h tz_scrsaver = NULL;
-
- Eina_Bool chk_found = EINA_FALSE;
- Eina_Bool chk_ly = EINA_FALSE;
- Eina_Bool chk_vis = EINA_FALSE;
- Eina_Bool chk_focus = EINA_FALSE;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
-
- tw = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, NULL,
- 0, 0, 0, 0, EINA_FALSE,
- 0, E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
-
- tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
- EINA_SAFETY_ON_NULL_GOTO(tzsh, cleanup);
-
- tz_win = elm_win_window_id_get(tw->elm_win);
- EINA_SAFETY_ON_FALSE_GOTO(tz_win, cleanup);
-
- tz_scrsaver = tzsh_screensaver_service_create(tzsh, tz_win);
- EINA_SAFETY_ON_NULL_GOTO(tz_scrsaver, cleanup);
-
- res = e_test_runner_req_win_register(tc->runner, tw);
- EINA_SAFETY_ON_FALSE_GOTO(res, cleanup);
-
- e_tc_win_geom_update(tw);
- e_tc_win_show(tw);
- e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON);
-
- l = e_test_runner_req_win_info_list_get(tc->runner);
- EINA_SAFETY_ON_NULL_GOTO(l, cleanup);
-
- EINA_LIST_FOREACH(l, ll, tw2)
- {
- if (tw2->native_win != tw->native_win) continue;
-
- chk_found = EINA_TRUE;
-
- if (tw2->layer == E_LAYER_CLIENT_ALERT)
- chk_ly = EINA_TRUE;
-
- if ((tw2->vis.win) &&
- (tw2->vis.obj) &&
- (tw2->vis.type == E_VISIBILITY_UNOBSCURED))
- chk_vis = EINA_TRUE;
-
- if ((tw2->focus.obj) &&
- (tw2->focus.win))
- chk_focus = EINA_TRUE;
-
- break;
- }
-
- EINA_SAFETY_ON_FALSE_GOTO(chk_found, cleanup);
- EINA_SAFETY_ON_FALSE_GOTO(chk_ly, cleanup);
- EINA_SAFETY_ON_FALSE_GOTO(chk_vis, cleanup);
- EINA_SAFETY_ON_FALSE_GOTO(chk_focus, cleanup);
-
- tc->passed = EINA_TRUE;
-
-cleanup:
- e_test_runner_req_win_info_list_free(l);
- e_tc_win_hide(tw);
- e_test_runner_req_win_deregister(tc->runner, tw);
- e_tc_win_del(tw);
-
- tzsh_screensaver_service_destroy(tz_scrsaver);
- tzsh_destroy(tzsh);
-
- return tc->passed;
-}
-
-struct _E_TC_Data
-{
- E_Test_Runner *runner;
- Ecore_Timer *expire_timer;
-
- /* 0401 */
- Eina_Bool chk_timeout_val;
- Eina_Bool chk_ev_state_idle_timeout;
- Eina_Bool chk_ev_state_not_idle;
- int chk_cb_called;
-};
-
-static Eina_Bool
-_cb_timeout(void *data)
-{
- E_TC_Data *tc_data = data;
-
- tc_data->expire_timer = NULL;
-
- elm_exit();
-
- return ECORE_CALLBACK_DONE;
-}
-
-static void
-_cb_state_change(void *data,
- tzsh_screensaver_manager_service_h service,
- int states)
-{
- E_TC_Data *tc_data = data;
- unsigned int time;
-
- tc_data->chk_cb_called++;
-
- if (states & TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_IDLE_TIMEOUT_EXPIRED)
- {
- EINA_SAFETY_ON_FALSE_RETURN(tc_data->chk_cb_called == 1);
-
- if (tc_data->expire_timer)
- {
- ecore_timer_del(tc_data->expire_timer);
- tc_data->expire_timer = NULL;
- }
- tc_data->expire_timer = ecore_timer_add(1.1, _cb_timeout, tc_data);
-
- tc_data->chk_ev_state_idle_timeout = EINA_TRUE;
-
- e_test_runner_req_ev_thaw(tc_data->runner);
- e_test_runner_req_ev_feed_mouse_down(tc_data->runner, 1, 1);
- e_test_runner_req_ev_feed_mouse_up(tc_data->runner, 1, 1);
- e_test_runner_req_ev_freeze(tc_data->runner);
- }
- else if (states & TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE)
- {
- EINA_SAFETY_ON_FALSE_RETURN(tc_data->chk_cb_called == 2);
-
- if (tc_data->expire_timer)
- {
- ecore_timer_del(tc_data->expire_timer);
- tc_data->expire_timer = NULL;
- }
-
- tc_data->chk_ev_state_not_idle = EINA_TRUE;
-
- tzsh_screensaver_manager_service_idle_timeout_get(service, &time);
- EINA_SAFETY_ON_FALSE_RETURN(time == 1000);
-
- tc_data->chk_timeout_val = EINA_TRUE;
-
- elm_exit();
- }
- else
- {
- EINA_SAFETY_ON_FALSE_RETURN(EINA_FALSE);
- }
-}
-
-/* Name:
- * [0401] screensaver manager basic
- * Description:
- * Check screensaver manager APIs and 'state changed' callback
- * Steps:
- * 01. Create an elm basic window that won't be shown
- * 02. Set elm window to be screensaver manager using tzsh
- * 03. Set idle timeout to 1.0 seconds
- * 04. Set screensaver feature enabled
- * 05. Check TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_IDLE_TIMEOUT_EXPIRED event
- * 06. Request to feed fake key event
- * 07. Check TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE event
- * Expected results:
- * TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_IDLE_TIMEOUT_EXPIRED event occurs.
- * TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE event occurs.
- */
-Eina_Bool
-tc_0401_scrsaver_mng_basic(E_TC *tc)
-{
- E_TC_Win *tw = NULL;
- tzsh_h tzsh = NULL;
- tzsh_window tz_win = 0x0;
- tzsh_screensaver_manager_service_h tz_scrsaver_mng = NULL;
- int res = 0;
- E_TC_Data *data;
-
- EINA_SAFETY_ON_NULL_RETURN_VAL(tc, EINA_FALSE);
-
- data = E_NEW(E_TC_Data, 1);
- EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
-
- tw = e_tc_win_add(NULL, ELM_WIN_BASIC, EINA_FALSE, NULL,
- 0, 0, 0, 0, EINA_FALSE,
- 0, E_TC_WIN_COLOR_RED);
- EINA_SAFETY_ON_NULL_GOTO(tw, cleanup);
-
- tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
- EINA_SAFETY_ON_NULL_GOTO(tzsh, cleanup);
-
- tz_win = elm_win_window_id_get(tw->elm_win);
- EINA_SAFETY_ON_FALSE_GOTO(tz_win, cleanup);
-
- tz_scrsaver_mng = tzsh_screensaver_manager_service_create(tzsh, tz_win);
- EINA_SAFETY_ON_NULL_GOTO(tz_scrsaver_mng, cleanup);
-
- res = tzsh_screensaver_manager_service_idle_timeout_set(tz_scrsaver_mng, 1000);
- EINA_SAFETY_ON_FALSE_GOTO(res == 0, cleanup);
-
- res = tzsh_screensaver_manager_service_enable(tz_scrsaver_mng);
- EINA_SAFETY_ON_FALSE_GOTO(res == 0, cleanup);
-
- res = tzsh_screensaver_manager_service_state_change_cb_set(tz_scrsaver_mng,
- _cb_state_change,
- data);
- EINA_SAFETY_ON_FALSE_GOTO(res == 0, cleanup);
-
- data->expire_timer = ecore_timer_add(1.1, _cb_timeout, data);
- data->runner = tc->runner;
-
- e_test_runner_req_ev_freeze(tc->runner);
-
- e_test_runner_work();
-
- e_test_runner_req_ev_thaw(tc->runner);
-
- EINA_SAFETY_ON_FALSE_GOTO(data->chk_ev_state_idle_timeout, cleanup);
- EINA_SAFETY_ON_FALSE_GOTO(data->chk_ev_state_not_idle, cleanup);
- EINA_SAFETY_ON_FALSE_GOTO(data->chk_timeout_val, cleanup);
- EINA_SAFETY_ON_FALSE_GOTO(data->chk_cb_called == 2, cleanup);
-
- tc->passed = EINA_TRUE;
-
-cleanup:
- if (data->expire_timer) ecore_timer_del(data->expire_timer);
- E_FREE(data);
- e_tc_win_del(tw);
- tzsh_screensaver_manager_service_destroy(tz_scrsaver_mng);
- tzsh_destroy(tzsh);
-
- return tc->passed;
-}
+++ /dev/null
-#include "e_test_runner.h"
-
-static Eina_Bool
-_e_tc_rot_win_rotation_test(E_Test_Runner *runner, E_TC_Win *tw, int rot)
-{
- Eina_Bool res;
-
- res = e_test_runner_req_zone_rotation_change(runner, rot);
- if (!res)
- {
- ERR("Changing rotaiton is denied.");
- return EINA_FALSE;
- }
-
- res = e_test_runner_ev_wait(runner, E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
- if (!res)
- {
- ERR("Failed waiting rotation change event");
- return EINA_FALSE;
- }
-
- res = e_test_runner_req_win_info_get(runner, tw);
- if ((!res) ||
- (tw->rot != rot))
- {
- ERR("Failed to rotate res %d, pass %d, result %d", res, rot, tw->rot);
- return EINA_FALSE;
- }
-
- return EINA_TRUE;
-}
-
-/* @ Brief
- * Test whether available rotation works fine for a window.
- *
- * @ Test Step:
- * 1. Creating a Window
- * 2. Set a available rotation list(0, 90, 180, 270) to window
- * 3. Request to server for rotation about all available angles.
- * 4. Verifying a window is rotated.
- *
- * @ Expected Result:
- * Window should be rotated after accepted request for rotation.
- */
-ROT_TC_DEFINE(00, available_rots)
-{
- E_TC_Win *tw;
- Eina_Bool res;
- int rot, saved_rot;
- const int rots[4] = {0, 90, 180, 270};
-
- /* create window */
- tw = e_tc_win_add(NULL, ELM_WIN_BASIC,
- EINA_FALSE, "Test Window for Rotation",
- 0, 0, 0, 0, EINA_FALSE,
- 200, E_TC_WIN_COLOR_BLUE);
- EINA_SAFETY_ON_NULL_GOTO(tw, end);
-
- /* set available rotations */
- elm_win_wm_rotation_available_rotations_set(tw->elm_win, rots, 4);
-
- /* register window */
- res = e_test_runner_req_win_register(tc->runner, tw);
- if (!res)
- goto err_reg;
-
- e_tc_win_geom_update(tw);
- e_tc_win_show(tw);
- e_test_runner_ev_wait(tc->runner, E_TC_EVENT_TYPE_VIS_ON);
-
- /* Update window info */
- res = e_test_runner_req_win_info_get(tc->runner, tw);
- if (!res)
- {
- ERR("Failed to get initial window info");
- goto err_info_get;
- }
-
- /* to restore orientation after finishing tc */
- saved_rot = tw->rot;
-
- for (rot = ((saved_rot + 90) % 360);
- rot == saved_rot;
- rot = ((rot + 90) % 360))
- {
- /* hard coded, reverse portrait(180) mode is disabled in mobile */
- if (rot == 180) continue;
-
- res = _e_tc_rot_win_rotation_test(tc->runner, tw, rot);
- if (!res)
- {
- ERR("Failed to try to rotate given angle: %d", rot);
- goto err_tc;
- }
- }
-
- tc->passed = EINA_TRUE;
-
-err_tc:
- /* restore orientation */
- res = e_test_runner_req_zone_rotation_change(tc->runner, saved_rot);
- if (!res)
- ERR("Failed to restore orientation");
-err_info_get:
- e_test_runner_req_win_deregister(tc->runner, tw);
- e_tc_win_hide(tw);
-err_reg:
- e_tc_win_del(tw);
-end:
- return tc->passed;
-}
+++ /dev/null
-#ifndef TC_ROTATION_H
-#define TC_ROTATION_H
-
-#include <Eina.h>
-
-#define ROT_TC_DEFINE(num, name) Eina_Bool tc_05##num##_rotation_##name(E_TC *tc)
-
-ROT_TC_DEFINE(00, available_rots);
-
-#endif
@E_TEST_RUNNER_LIBS@
e_test_runner_TESTCASES = \
-testcase/1_easy.cpp \
-testcase/2_base_operation.cpp \
-testcase/3_base_operation_multi_wins.cpp \
-testcase/4_transient_for.cpp \
-testcase/5_notification.cpp
+testcase/0001_easy.cpp \
+testcase/0002_base_operation.cpp \
+testcase/0003_base_operation_multi_wins.cpp \
+testcase/0004_transient_for.cpp \
+testcase/0005_notification.cpp \
+testcase/0006_tzsh.cpp \
+testcase/0007_rotation.cpp \
+testcase/0008_focus.cpp
e_test_runner_SOURCES = \
e_test_main.cpp \
e_test_win.h \
e_test_win.cpp \
e_test_util.h \
-testcase/1_easy.cpp \
-testcase/2_base_operation.cpp \
-testcase/3_base_operation_multi_wins.cpp \
-testcase/4_transient_for.cpp \
-testcase/5_notification.cpp
+testcase/0001_easy.cpp \
+testcase/0002_base_operation.cpp \
+testcase/0003_base_operation_multi_wins.cpp \
+testcase/0004_transient_for.cpp \
+testcase/0005_notification.cpp \
+testcase/0006_tzsh.cpp \
+testcase/0007_rotation.cpp \
+testcase/0008_focus.cpp
MAINTAINERCLEANFILES = \
Makefile.in
EtEventLoop::EtEventLoop()
{
this->log_dom_ = -1;
+ this->time_for_wait_work_ = E_TEST_WORK_TIME;
this->tizen_policy_ = NULL;
this->tizen_surface_ = NULL;
void EtEventLoop::Work()
{
/* give a turn to deal with deferred job for E_TEST_WORK_TIME */
- ecore_timer_add(E_TEST_WORK_TIME, _cb_work_timeout, NULL);
+ ecore_timer_add(time_for_wait_work_, _cb_work_timeout, NULL);
elm_run();
}
(unsigned int)tw->native_win,
tw->alpha,
tw->x, tw->y, tw->w, tw->h,
- tw->vis.win,
- tw->vis.obj,
- tw->vis.opaque,
- tw->vis.type,
- tw->vis.skip,
+ tw->Vis.win,
+ tw->Vis.obj,
+ tw->Vis.opaque,
+ tw->Vis.type,
+ tw->Vis.skip,
tw->iconic,
- tw->focus.win,
- tw->focus.obj,
+ tw->Focus.win,
+ tw->Focus.obj,
tw->name);
}
this->FreeWinInfoList(l);
printf("--------------------------------------------------------------------------------------------------------------------------\n");
}
+void EtEventLoop::DelTimer()
+{
+ if (this->Ev.expire_timer)
+ {
+ ecore_timer_del(this->Ev.expire_timer);
+ this->Ev.expire_timer = NULL;
+ }
+}
+
+void EtEventLoop::RunTimer()
+{
+ if (this->Ev.expire_timer)
+ this->DelTimer();
+
+ this->Ev.expire_timer = ecore_timer_add(this->time_for_wait_work_, _cb_work_timeout, NULL);
+}
+
+void EtEventLoop::WaitForDestroy()
+{
+ printf("###########################\n");
+ printf("Destroy Wait Timer Start!!!\n");
+ printf("###########################\n");
+ this->SetWaitWorkTime(E_TEST_WORK_TIME);
+ this->RunTimer();
+ elm_run();
+}
+
Ecore_Window EtEventLoop::GetWinId(Evas_Object *elm_win)
{
Ecore_Wl_Window *wlwin = NULL;
&tw->x, &tw->y, &tw->w, &tw->h,
&tw->layer,
&tw->effect,
- &tw->vis.win,
- &tw->vis.obj,
- &tw->vis.opaque,
- &tw->vis.type,
- &tw->vis.skip,
+ &tw->Vis.win,
+ &tw->Vis.obj,
+ &tw->Vis.opaque,
+ &tw->Vis.type,
+ &tw->Vis.skip,
&tw->iconic,
&tw->alpha,
- &tw->focus.win,
- &tw->focus.obj,
+ &tw->Focus.win,
+ &tw->Focus.obj,
&tw->rot);
if (wname)
&tw->x, &tw->y, &tw->w, &tw->h,
&tw->layer,
&tw->effect,
- &tw->vis.win,
- &tw->vis.obj,
- &tw->vis.opaque,
- &tw->vis.type,
- &tw->vis.skip,
+ &tw->Vis.win,
+ &tw->Vis.obj,
+ &tw->Vis.opaque,
+ &tw->Vis.type,
+ &tw->Vis.skip,
&tw->iconic,
&tw->alpha,
- &tw->focus.win,
- &tw->focus.obj,
+ &tw->Focus.win,
+ &tw->Focus.obj,
&tw->rot);
if (wname)
struct tizen_surface *tizen_surface_ = NULL;
int log_dom_ = -1;
+ double time_for_wait_work_ = 0.0;
struct
{
/* methods */
void Work();
void PrintWinInfoList();
+ void SetWaitWorkTime(double time) { this->time_for_wait_work_ = time; };
+ void DelTimer();
+ void RunTimer();
+ void WaitForDestroy();
/* getter & setter */
Eldbus_Connection *GetEldbusConnection() { return this->Dbus.conn; };
int opaque = 0;
E_Visibility type = E_VISIBILITY_UNKNOWN;
Eina_Bool skip = EINA_FALSE;
- } vis;
+ } Vis;
Eina_Bool iconic = EINA_FALSE;
Eina_Bool alpha = EINA_FALSE;
struct
{
Eina_Bool win = EINA_FALSE;
Eina_Bool obj = EINA_FALSE;
- } focus;
+ } Focus;
public:
EtWin();
extern EtEventLoop *gLoop;
-class TestcaseEasy : public ::testing::Test
+class EtTestEasy : public ::testing::Test
{
protected:
static void SetUpTestCase() {};
elm_exit();
}
-TEST_F(TestcaseEasy, base_pass)
+TEST_F(EtTestEasy, base_pass)
{
Eina_Bool result = EINA_TRUE;
ASSERT_TRUE(result);
}
-TEST_F(TestcaseEasy, base_fail)
+TEST_F(EtTestEasy, base_fail)
{
Eina_Bool result = EINA_FALSE;
ASSERT_FALSE(result);
}
-TEST_F(TestcaseEasy, introspect)
+TEST_F(EtTestEasy, introspect)
{
Eina_Bool result = EINA_FALSE;
Eldbus_Pending *p = NULL;
ASSERT_TRUE(result);
}
-TEST_F(TestcaseEasy, win_register)
+TEST_F(EtTestEasy, win_register)
{
Eina_Bool result = EINA_FALSE;
Eldbus_Pending *p = NULL;
extern EtEventLoop *gLoop;
-class TestcaseBaseOperation : public ::testing::Test
+class EtTestBaseOperation : public ::testing::Test
{
public:
- TestcaseBaseOperation()
+ EtTestBaseOperation()
{
};
- ~TestcaseBaseOperation()
+ ~EtTestBaseOperation()
{
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
+ gLoop->WaitForDestroy();
if (tw)
{
gLoop->DeregisterWin(tw);
tw->DeInit();
delete tw;
+ tw = NULL;
}
+
+ if (gLoop->HasLastWinInfoList())
+ gLoop->FreeLastWinInfoList();
};
protected:
};
};
-TEST_F(TestcaseBaseOperation, win_show)
+TEST_F(EtTestBaseOperation, win_show)
{
Eina_Bool result = EINA_FALSE;
ASSERT_TRUE(result);
}
-TEST_F(TestcaseBaseOperation, win_stack)
+TEST_F(EtTestBaseOperation, win_stack)
{
EtWin *tw2 = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_TRUE(result);
}
-TEST_F(TestcaseBaseOperation, alpha_win_show)
+TEST_F(EtTestBaseOperation, alpha_win_show)
{
Eina_Bool result = EINA_FALSE;
ASSERT_TRUE(result);
}
-TEST_F(TestcaseBaseOperation, alpha_win_stack)
+TEST_F(EtTestBaseOperation, alpha_win_stack)
{
EtWin *tw2 = NULL;
Eina_Bool result = EINA_FALSE;
extern EtEventLoop *gLoop;
-class TestcaseBaseMulti : public ::testing::Test
+class EtTestBaseMulti : public ::testing::Test
{
public:
- TestcaseBaseMulti()
+ EtTestBaseMulti()
{
};
- ~TestcaseBaseMulti()
+ ~EtTestBaseMulti()
{
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
+ gLoop->WaitForDestroy();
if (tw_register)
gLoop->DeregisterWin(tw_register);
if (tw_green)
delete tw_green;
+
+ if (gLoop->HasLastWinInfoList())
+ gLoop->FreeLastWinInfoList();
};
protected:
}
};
-TEST_F(TestcaseBaseMulti, multi_all_wins_basic)
+TEST_F(EtTestBaseMulti, multi_all_wins_basic)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_show1)
+TEST_F(EtTestBaseMulti, multi_all_wins_show1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_show2)
+TEST_F(EtTestBaseMulti, multi_all_wins_show2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_show3)
+TEST_F(EtTestBaseMulti, multi_all_wins_show3)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_raise1)
+TEST_F(EtTestBaseMulti, multi_all_wins_raise1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_raise2)
+TEST_F(EtTestBaseMulti, multi_all_wins_raise2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_stack_above1)
+TEST_F(EtTestBaseMulti, multi_all_wins_stack_above1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_stack_above2)
+TEST_F(EtTestBaseMulti, multi_all_wins_stack_above2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_stack_above3)
+TEST_F(EtTestBaseMulti, multi_all_wins_stack_above3)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_lower1)
+TEST_F(EtTestBaseMulti, multi_all_wins_lower1)
{
EtWin *tw = NULL, *tw_above = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_wins_lower2)
+TEST_F(EtTestBaseMulti, multi_all_wins_lower2)
{
EtWin *tw = NULL, *tw_above = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_basic)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_basic)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_show1)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_show1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_show2)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_show2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_show3)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_show3)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_raise1)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_raise1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_raise2)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_raise2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_stack_above1)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_stack_above1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_stack_above2)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_stack_above2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_stack_above3)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_stack_above3)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_lower1)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_lower1)
{
EtWin *tw = NULL, *tw_above = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_all_full_wins_lower2)
+TEST_F(EtTestBaseMulti, multi_all_full_wins_lower2)
{
EtWin *tw = NULL, *tw_above = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_2wins_show1)
+TEST_F(EtTestBaseMulti, multi_2wins_show1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(2, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_2wins_show2)
+TEST_F(EtTestBaseMulti, multi_2wins_show2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(2, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_2wins_show3)
+TEST_F(EtTestBaseMulti, multi_2wins_show3)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(2, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_full_2wins_show1)
+TEST_F(EtTestBaseMulti, multi_full_2wins_show1)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(2, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_full_2wins_show2)
+TEST_F(EtTestBaseMulti, multi_full_2wins_show2)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(2, pass_count);
}
-TEST_F(TestcaseBaseMulti, multi_full_2wins_show3)
+TEST_F(EtTestBaseMulti, multi_full_2wins_show3)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
extern EtEventLoop *gLoop;
-class TestcaseTransientFor : public ::testing::Test
+class EtTestTransientFor : public ::testing::Test
{
public:
- TestcaseTransientFor()
+ EtTestTransientFor()
{
};
- ~TestcaseTransientFor()
+ ~EtTestTransientFor()
{
- if (gLoop->HasLastWinInfoList())
- gLoop->FreeLastWinInfoList();
+ gLoop->WaitForDestroy();
if (tw_register)
gLoop->DeregisterWin(tw_register);
if (tw_child)
delete tw_child;
+
+ if (gLoop->HasLastWinInfoList())
+ gLoop->FreeLastWinInfoList();
};
protected:
};
};
-TEST_F(TestcaseTransientFor, transient_for_basic)
+TEST_F(EtTestTransientFor, transient_for_basic)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseTransientFor, transient_for_raise)
+TEST_F(EtTestTransientFor, transient_for_raise)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseTransientFor, transient_for_lower)
+TEST_F(EtTestTransientFor, transient_for_lower)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseTransientFor, transient_for_above)
+TEST_F(EtTestTransientFor, transient_for_above)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
extern EtEventLoop *gLoop;
-class TestcaseNotification : public ::testing::Test
+class EtTestNotification : public ::testing::Test
{
public:
- TestcaseNotification()
+ EtTestNotification()
{
};
- ~TestcaseNotification()
+ ~EtTestNotification()
{
+ gLoop->WaitForDestroy();
+
if (tw_register)
gLoop->DeregisterWin(tw_register);
if (tw_noti2)
delete tw_noti2;
+
+ if (gLoop->HasLastWinInfoList())
+ gLoop->FreeLastWinInfoList();
};
protected:
}
};
-TEST_F(TestcaseNotification, notification_level_default)
+TEST_F(EtTestNotification, notification_level_default)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_level_medium)
+TEST_F(EtTestNotification, notification_level_medium)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_level_high)
+TEST_F(EtTestNotification, notification_level_high)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_level_top)
+TEST_F(EtTestNotification, notification_level_top)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_level_none)
+TEST_F(EtTestNotification, notification_level_none)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_level_change)
+TEST_F(EtTestNotification, notification_level_change)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_fullsize_level_default)
+TEST_F(EtTestNotification, notification_fullsize_level_default)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_fullsize_level_medium)
+TEST_F(EtTestNotification, notification_fullsize_level_medium)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_fullsize_level_high)
+TEST_F(EtTestNotification, notification_fullsize_level_high)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_fullsize_level_top)
+TEST_F(EtTestNotification, notification_fullsize_level_top)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_fullsize_level_none)
+TEST_F(EtTestNotification, notification_fullsize_level_none)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
ASSERT_EQ(3, pass_count);
}
-TEST_F(TestcaseNotification, notification_fullsize_level_change)
+TEST_F(EtTestNotification, notification_fullsize_level_change)
{
EtWin *tw = NULL;
Eina_Bool result = EINA_FALSE;
--- /dev/null
+#include "e_test_event.h"
+
+#include <tzsh_screensaver_manager_service.h>
+#include <tzsh_screensaver_service.h>
+
+#define E_TEST_WORK_TIME 3.0
+
+using ::testing::Test;
+
+extern EtEventLoop *gLoop;
+
+class EtTestTzsh : public :: testing::Test
+{
+ public:
+ Eina_Bool chk_timeout_val_ = EINA_FALSE;
+ Eina_Bool chk_ev_state_idle_timeout_ = EINA_FALSE;
+ Eina_Bool chk_ev_state_not_idle_ = EINA_FALSE;
+ int chk_cb_called_ = 0;
+
+ tzsh_h tzsh = NULL;
+ tzsh_window tz_win = 0x0;
+ tzsh_screensaver_service_h tz_scrsaver = NULL;
+ tzsh_screensaver_manager_service_h tz_scrsaver_mng = NULL;
+
+ EtTestTzsh()
+ {
+ chk_timeout_val_ = EINA_FALSE;
+ chk_ev_state_idle_timeout_ = EINA_FALSE;
+ chk_ev_state_not_idle_ = EINA_FALSE;
+ chk_cb_called_ = 0;
+ };
+ ~EtTestTzsh()
+ {
+ gLoop->WaitForDestroy();
+
+ if (tz_scrsaver_mng)
+ tzsh_screensaver_manager_service_destroy(tz_scrsaver_mng);
+
+ if (tz_scrsaver)
+ tzsh_screensaver_service_destroy(tz_scrsaver);
+
+ if (tzsh)
+ tzsh_destroy(tzsh);
+
+ if (tw)
+ {
+ gLoop->DeregisterWin(tw);
+ delete tw;
+ }
+
+ if (gLoop->HasLastWinInfoList())
+ gLoop->FreeLastWinInfoList();
+ };
+ protected:
+ EtWin *tw = NULL;
+
+ Eina_Bool InitTC()
+ {
+ Eina_Bool result = EINA_FALSE;
+
+ this->tw = new EtWin();
+ result = this->tw->Init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "EtWin Tzsh",
+ 0, 0, 0, 0, EINA_FALSE,
+ (E_Layer) 0,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+ this->tw->native_win = gLoop->GetWinId(this->tw->elm_win);
+
+ result = gLoop->RegisterWin(this->tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+
+ return EINA_TRUE;
+ };
+};
+
+/******************
+ callbacks
+*******************/
+static void
+_cb_state_change(void *data,
+ tzsh_screensaver_manager_service_h service,
+ int states)
+{
+ EtTestTzsh *tc_data = (EtTestTzsh *)data;
+ unsigned int time;
+
+ tc_data->chk_cb_called_++;
+
+ if (states & TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_IDLE_TIMEOUT_EXPIRED)
+ {
+ EINA_SAFETY_ON_FALSE_RETURN(tc_data->chk_cb_called_ == 1);
+
+ gLoop->RunTimer();
+
+ tc_data->chk_ev_state_idle_timeout_ = EINA_TRUE;
+
+ gLoop->ThawEvent();
+ gLoop->FeedMouseDown(1, 1);
+ gLoop->FeedMouseUp(1, 1);
+ gLoop->FreezeEvent();
+ }
+ else if (states & TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE)
+ {
+ EINA_SAFETY_ON_FALSE_RETURN(tc_data->chk_cb_called_ == 2);
+
+ gLoop->DelTimer();
+
+ tc_data->chk_ev_state_not_idle_ = EINA_TRUE;
+
+ tzsh_screensaver_manager_service_idle_timeout_get(service, &time);
+ EINA_SAFETY_ON_FALSE_RETURN(time == 1000);
+
+ tc_data->chk_timeout_val_ = EINA_TRUE;
+
+ elm_exit();
+ }
+ else
+ {
+ EINA_SAFETY_ON_FALSE_RETURN(EINA_FALSE);
+ }
+}
+
+/* Name:
+ * EtTestTzsh.scrsaver_basic
+ * Description:
+ * Check screensaver type window that is shown on the notification layer.
+ * Steps:
+ * 01. Create an elm basic window
+ * 02. Set elm window to be screensaver type using tzsh
+ * 03. Show window
+ * 04. Check window stack
+ * Expected results:
+ * A window is shown on the notification layer.
+ */
+TEST_F(EtTestTzsh, scrsaver_basic)
+{
+ Eina_Bool result = EINA_FALSE;
+ Eina_List *list = NULL, *l = NULL;
+ EtWin *tw = NULL;
+
+ this->InitTC();
+
+ this->tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
+ ASSERT_TRUE(this->tzsh != NULL);
+
+ this->tz_win = elm_win_window_id_get(this->tw->elm_win);
+ ASSERT_NE(0, this->tz_win);
+
+ this->tz_scrsaver = tzsh_screensaver_service_create(this->tzsh, this->tz_win);
+ ASSERT_TRUE(tz_scrsaver != NULL);
+
+ this->tw->UpdateGeometry();
+ this->tw->Show();
+ gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
+
+ list = gLoop->GetWinInfoList();
+ ASSERT_TRUE(list != NULL);
+
+ EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ {
+ if (tw->native_win != this->tw->native_win)
+ continue;
+
+ // check layer
+ ASSERT_EQ(E_LAYER_CLIENT_ALERT, tw->layer);
+
+ // check visibility
+ ASSERT_TRUE(tw->Vis.win);
+ ASSERT_TRUE(tw->Vis.obj);
+ ASSERT_EQ(E_VISIBILITY_UNOBSCURED, tw->Vis.type);
+
+ // check focus
+ ASSERT_TRUE(tw->Focus.obj);
+ ASSERT_TRUE(tw->Focus.win);
+
+ break;
+ }
+ gLoop->FreeWinInfoList(list);
+
+}
+
+/* Name:
+ * EtTestTzsh.Screensaver_manager_basic
+ * Description:
+ * Check screensaver manager APIs and 'state changed' callback
+ * Steps:
+ * 01. Create an elm basic window that won't be shown
+ * 02. Set elm window to be screensaver manager using tzsh
+ * 03. Set idle timeout to 1.0 seconds
+ * 04. Set screensaver feature enabled
+ * 05. Check TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_IDLE_TIMEOUT_EXPIRED event
+ * 06. Request to feed fake key event
+ * 07. Check TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE event
+ * Expected results:
+ * TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_IDLE_TIMEOUT_EXPIRED event occurs.
+ * TZSH_SCREENSAVER_MANAGER_SERVICE_STATE_NOT_IDLE event occurs.
+ */
+TEST_F(EtTestTzsh, scrsaver_mng_basic)
+{
+ Eina_Bool result = EINA_FALSE;
+
+ result = this->InitTC();
+ ASSERT_TRUE(result);
+
+ this->tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
+ ASSERT_TRUE(this->tzsh != NULL);
+
+ this->tz_win = elm_win_window_id_get(this->tw->elm_win);
+ ASSERT_NE(0, this->tz_win);
+
+ this->tz_scrsaver_mng = tzsh_screensaver_manager_service_create(this->tzsh, this->tz_win);
+ ASSERT_TRUE(this->tz_scrsaver_mng != NULL);
+
+ result = tzsh_screensaver_manager_service_idle_timeout_set(this->tz_scrsaver_mng, 1000);
+ ASSERT_EQ(TZSH_ERROR_NONE, result);
+
+ result = tzsh_screensaver_manager_service_enable(this->tz_scrsaver_mng);
+ ASSERT_EQ(TZSH_ERROR_NONE, result);
+
+ result = tzsh_screensaver_manager_service_state_change_cb_set(this->tz_scrsaver_mng,
+ _cb_state_change,
+ this);
+ ASSERT_EQ(TZSH_ERROR_NONE, result);
+
+ gLoop->SetWaitWorkTime(1.1);
+ gLoop->FreezeEvent();
+ gLoop->Work();
+ gLoop->ThawEvent();
+ gLoop->SetWaitWorkTime(E_TEST_WORK_TIME);
+
+ ASSERT_TRUE(this->chk_ev_state_idle_timeout_);
+ ASSERT_TRUE(this->chk_ev_state_not_idle_);
+ ASSERT_TRUE(this->chk_timeout_val_);
+ ASSERT_EQ(2, this->chk_cb_called_);
+
+}
--- /dev/null
+#include "e_test_event.h"
+
+using ::testing::Test;
+
+extern EtEventLoop *gLoop;
+
+class EtTestRotation : public ::testing::Test
+{
+ public:
+ EtTestRotation()
+ {
+ };
+ ~EtTestRotation()
+ {
+ gLoop->WaitForDestroy();
+
+ if (tw_register)
+ gLoop->DeregisterWin(tw_register);
+
+ if (tw)
+ {
+ delete tw;
+ }
+
+ if (gLoop->HasLastWinInfoList())
+ gLoop->FreeLastWinInfoList();
+ };
+
+ protected:
+ const int rots[4] = {0, 90, 180, 270};
+ EtWin *tw = NULL;
+ EtWin *tw_register = NULL;
+
+ int saved_rot_ = 0;
+
+ Eina_Bool InitTC()
+ {
+ Eina_Bool result = EINA_FALSE;
+
+ this->tw = new EtWin();
+ result = this->tw->Init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "EtWin Rotation",
+ 0, 0, 400, 400, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_BLUE);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+ this->tw->native_win = gLoop->GetWinId(this->tw->elm_win);
+
+ // available rotations
+ elm_win_wm_rotation_available_rotations_set(this->tw->elm_win,
+ this->rots, 4);
+
+ result = gLoop->RegisterWin(this->tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+
+ this->tw_register = this->tw;
+
+ this->tw->UpdateGeometry();
+ this->tw->Show();
+ gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
+
+ return EINA_TRUE;
+ };
+
+ Eina_Bool TestWinRotation(EtWin *tw, int rot)
+ {
+ Eina_Bool result = EINA_FALSE;
+
+ result = gLoop->SetZoneRotation(rot);
+ if (!result)
+ {
+ ERR("Changing rotation is denied.");
+ return EINA_FALSE;
+ }
+
+ result = gLoop->WaitEvent(E_TC_EVENT_TYPE_WINDOW_ROTATION_CHANGE);
+ if (!result)
+ {
+ ERR("Failed waiting rotation change event");
+ return EINA_FALSE;
+ }
+
+ result = gLoop->GetWinInfo(tw);
+ if ((!result) || (tw->rot != rot))
+ {
+ ERR("Failed to rotate res %d, pass %d, result %d", result, rot, tw->rot);
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+ };
+};
+
+TEST_F(EtTestRotation, available_rotations)
+{
+ Eina_Bool result = EINA_FALSE;
+ int rot = 0;
+
+ result = this->InitTC();
+ ASSERT_TRUE(result);
+
+ result = gLoop->GetWinInfo(this->tw);
+ ASSERT_TRUE(result);
+
+ this->saved_rot_ = this->tw->rot;
+
+ for (rot = ((this->saved_rot_ + 90) % 360);
+ rot == this->saved_rot_;
+ rot = ((rot + 90) % 360))
+ {
+ /* hard coded, reverse portrait(180) mode is disabled in mobile */
+ if (rot == 180) continue;
+
+ result = this->TestWinRotation(this->tw, rot);
+ ASSERT_TRUE(result);
+ }
+}
--- /dev/null
+#include "e_test_event.h"
+
+using ::testing::Test;
+
+extern EtEventLoop *gLoop;
+
+class EtTestFocus : public ::testing::Test
+{
+ public:
+ EtTestFocus()
+ {
+ };
+ ~EtTestFocus()
+ {
+ gLoop->WaitForDestroy();
+
+ if (this->tw_register)
+ {
+ gLoop->DeregisterWin(this->tw_register);
+ this->tw_register = NULL;
+ }
+
+ if (this->tw_red)
+ {
+ delete this->tw_red;
+ this->tw_red = NULL;
+ }
+
+ if (this->tw_green)
+ {
+ delete this->tw_green;
+ this->tw_green = NULL;
+ }
+
+ if (this->tw_blue)
+ {
+ delete this->tw_blue;
+ this->tw_blue = NULL;
+ }
+
+ if (gLoop->HasLastWinInfoList())
+ gLoop->FreeLastWinInfoList();
+ };
+
+ protected:
+ EtWin *tw_red = NULL;
+ EtWin *tw_green = NULL;
+ EtWin *tw_blue = NULL;
+
+ EtWin *tw_register = NULL;
+
+ Eina_Bool InitTC(Eina_Bool show_win, Eina_Bool use_geom)
+ {
+ Eina_Bool result = EINA_FALSE;
+
+ this->tw_red = new EtWin();
+ result = this->tw_red->Init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "EtWin Red",
+ 0, 0, 720, 640, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_RED);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+ this->tw_red->native_win = gLoop->GetWinId(this->tw_red->elm_win);
+
+ if (show_win)
+ {
+ this->tw_red->UpdateGeometry();
+ this->tw_red->Show();
+ }
+
+ this->tw_green = new EtWin();
+ result = this->tw_green->Init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "EtWin Green",
+ 0, 0, 720, 640, EINA_FALSE,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_GREEN);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+ this->tw_green->native_win = gLoop->GetWinId(this->tw_green->elm_win);
+
+ if (show_win)
+ {
+ this->tw_green->UpdateGeometry();
+ this->tw_green->Show();
+ }
+
+ this->tw_blue = new EtWin();
+ result = this->tw_blue->Init(NULL,
+ ELM_WIN_BASIC,
+ EINA_FALSE,
+ "EtWin Blue",
+ 0, 0, 720, 640, use_geom,
+ E_LAYER_CLIENT_NORMAL,
+ E_TC_WIN_COLOR_GREEN);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+ this->tw_blue->native_win = gLoop->GetWinId(this->tw_blue->elm_win);
+
+ if (show_win)
+ {
+ this->tw_blue->UpdateGeometry();
+ this->tw_blue->Show();
+
+ this->RegisterTCWin(this->tw_blue);
+ }
+
+ gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_ON);
+
+ return EINA_TRUE;
+ };
+
+ Eina_Bool RegisterTCWin(EtWin *tw)
+ {
+ Eina_Bool result = EINA_FALSE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+
+ if (this->tw_register)
+ {
+ result = gLoop->DeregisterWin(this->tw_register);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+
+ this->tw_register = NULL;
+ }
+
+ result = gLoop->RegisterWin(tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+
+ this->tw_register = tw;
+
+ return EINA_TRUE;
+ };
+
+ Eina_Bool ShowTCWin(EtWin *tw)
+ {
+ Eina_Bool result = EINA_FALSE;
+
+ EINA_SAFETY_ON_NULL_RETURN_VAL(tw, EINA_FALSE);
+
+ result = this->RegisterTCWin(tw);
+ EINA_SAFETY_ON_FALSE_RETURN_VAL(result, EINA_FALSE);
+
+ tw->UpdateGeometry();
+ tw->Show();
+
+ return EINA_TRUE;
+ };
+};
+
+TEST_F(EtTestFocus, focus_basic)
+{
+ EtWin *tw = NULL;
+ Eina_Bool result = EINA_FALSE;
+ Eina_List *list = NULL, *l = NULL;
+
+ result = this->InitTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(result);
+
+ // Expected focus result:
+ // [Top] Blue[focused] -> Green -> Red [Bottom]
+ list = gLoop->GetWinInfoList();
+ ASSERT_TRUE(list != NULL);
+
+ EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ {
+ if (tw->native_win == this->tw_blue->native_win)
+ ASSERT_TRUE(tw->Focus.obj);
+ else
+ ASSERT_FALSE(tw->Focus.obj);
+ }
+ gLoop->FreeWinInfoList(list);
+}
+
+TEST_F(EtTestFocus, focus_lower)
+{
+ EtWin *tw = NULL;
+ Eina_Bool result = EINA_FALSE;
+ Eina_List *list = NULL, *l = NULL;
+
+ result = this->InitTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(result);
+
+ // make tw_blue lower
+ result = gLoop->SetWinStack(this->tw_blue, NULL, EINA_FALSE);
+ gLoop->WaitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ ASSERT_TRUE(result);
+
+ // Expected focus result:
+ // [Top] Green[focused] -> Red -> ... -> Blue [Bottom]
+ list = gLoop->GetWinInfoList();
+ ASSERT_TRUE(list != NULL);
+
+ EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ {
+ if (tw->native_win == this->tw_green->native_win)
+ ASSERT_TRUE(tw->Focus.obj);
+ else
+ ASSERT_FALSE(tw->Focus.obj);
+ }
+ gLoop->FreeWinInfoList(list);
+}
+
+TEST_F(EtTestFocus, focus_raise)
+{
+ EtWin *tw = NULL;
+ Eina_Bool result = EINA_FALSE;
+ Eina_List *list = NULL, *l = NULL;
+
+ result = this->InitTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(result);
+
+ // make tw_red raise
+ result = gLoop->SetWinStack(this->tw_red, NULL, EINA_TRUE);
+ gLoop->WaitEvent(E_TC_EVENT_TYPE_FOCUS_CHANGED);
+ ASSERT_TRUE(result);
+
+ // Expected focus result:
+ // [Top] Red[focused] -> Blue -> Green [Bottom]
+ list = gLoop->GetWinInfoList();
+ ASSERT_TRUE(list != NULL);
+
+ EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ {
+ if (tw->native_win == this->tw_red->native_win)
+ ASSERT_TRUE(tw->Focus.obj);
+ else
+ ASSERT_FALSE(tw->Focus.obj);
+ }
+ gLoop->FreeWinInfoList(list);
+}
+
+TEST_F(EtTestFocus, focus_destroy)
+{
+ EtWin *tw = NULL;
+ Eina_Bool result = EINA_FALSE;
+ Eina_List *list = NULL, *l = NULL;
+
+ result = this->InitTC(EINA_TRUE, EINA_FALSE);
+ ASSERT_TRUE(result);
+
+ // delete tw_blue
+ this->tw_blue->Hide();
+ delete this->tw_blue;
+ this->tw_blue = NULL;
+ gLoop->WaitEvent(E_TC_EVENT_TYPE_VIS_OFF);
+
+ // Expected focus result:
+ // [Top] Green[focused] -> Red [Bottom]
+ list = gLoop->GetWinInfoList();
+ ASSERT_TRUE(list != NULL);
+
+ EINA_LIST_CAST_FOREACH(list, l, tw, EtWin*)
+ {
+ if (tw->native_win == this->tw_green->native_win)
+ ASSERT_TRUE(tw->Focus.obj);
+ else
+ ASSERT_FALSE(tw->Focus.obj);
+ }
+ gLoop->FreeWinInfoList(list);
+}
projects / platform / core / uifw / e-tizen-testcase.git / commitdiff