elementary: move all legacy files to their expected new location.

71 files changed, 3964 insertions, 0 deletions

diff --git a/src/tests/elementary/.gitignore b/src/tests/elementary/.gitignore
new file mode 100644
index 0000000000..b14d3623bf
--- /dev/null
+++ b/src/tests/elementary/.gitignore
@@ -0,0 +1,8 @@
+/elm_suite
+/check-results.xml
+/elm_suite.log
+/elm_suite.trs
+/test-suite.log
+/elm_cxx_suite
+/elm_cxx_suite.log
+/elm_cxx_suite.trs
diff --git a/src/tests/elementary/Makefile.am b/src/tests/elementary/Makefile.am
new file mode 100644
index 0000000000..664077f84b
--- /dev/null
+++ b/src/tests/elementary/Makefile.am
@@ -0,0 +1,112 @@
+AM_TESTS_ENVIRONMENT = \
+	ELM_DATA_DIR=${top_builddir}/data \
+	ELM_RUN_IN_TREE=1
+
+AUTOMAKE_OPTIONS     = 1.4 foreign
+MAINTAINERCLEANFILES = Makefile.in
+EXTRA_DIST = \
+	elm_suite.h \
+	elm_test_helper.h
+
+TESTS = elm_suite
+check_PROGRAMS = elm_suite
+elm_suite_SOURCES = \
+	elm_suite.c \
+	elm_test_helper.c \
+	elm_test_atspi.c \
+	elm_test_check.c \
+	elm_test_colorselector.c \
+	elm_test_entry.c \
+	elm_test_init.c \
+	elm_test_list.c \
+	elm_test_button.c \
+	elm_test_image.c \
+	elm_test_photo.c \
+	elm_test_actionslider.c \
+	elm_test_box.c \
+	elm_test_table.c \
+	elm_test_thumb.c \
+	elm_test_menu.c \
+	elm_test_photocam.c \
+	elm_test_win.c \
+	elm_test_icon.c \
+	elm_test_prefs.c \
+	elm_test_map.c \
+	elm_test_glview.c \
+	elm_test_web.c \
+	elm_test_toolbar.c \
+	elm_test_grid.c \
+	elm_test_diskselector.c \
+	elm_test_notify.c \
+	elm_test_mapbuf.c \
+	elm_test_flip.c \
+	elm_test_layout.c \
+	elm_test_slider.c \
+	elm_test_ctxpopup.c \
+	elm_test_separator.c \
+	elm_test_calendar.c \
+	elm_test_inwin.c \
+	elm_test_gengrid.c \
+	elm_test_radio.c \
+	elm_test_scroller.c \
+	elm_test_frame.c \
+	elm_test_datetime.c \
+	elm_test_player.c \
+	elm_test_bg.c \
+	elm_test_video.c \
+	elm_test_segmentcontrol.c \
+	elm_test_progressbar.c \
+	elm_test_fileselector.c \
+	elm_test_fileselector_button.c \
+	elm_test_fileselector_entry.c \
+	elm_test_hoversel.c \
+	elm_test_multibuttonentry.c \
+	elm_test_naviframe.c \
+	elm_test_popup.c \
+	elm_test_bubble.c \
+	elm_test_clock.c \
+	elm_test_conformant.c \
+	elm_test_dayselector.c \
+	elm_test_flipselector.c \
+	elm_test_genlist.c \
+	elm_test_hover.c \
+	elm_test_index.c \
+	elm_test_label.c \
+	elm_test_panel.c \
+	elm_test_panes.c \
+	elm_test_slideshow.c \
+	elm_test_spinner.c \
+	elm_test_plug.c
+
+elm_suite_CPPFLAGS = \
+	-DTESTS_BUILD_DIR=\"${top_builddir}/src/tests\" \
+	-DELM_IMAGE_DATA_DIR=\"${top_srcdir}/data\" \
+	-I$(top_srcdir)/src/lib \
+	-I$(top_builddir)/src/lib \
+	@CHECK_CFLAGS@ \
+	@ELEMENTARY_CFLAGS@
+
+elm_suite_LDADD = \
+	$(top_builddir)/src/lib/libelementary.la \
+	@CHECK_LIBS@ \
+	@ELEMENTARY_LIBS@
+
+if HAVE_CXX11
+TESTS += elm_cxx_suite
+check_PROGRAMS += elm_cxx_suite
+
+elm_cxx_suite_SOURCES = elm_cxx_suite.cc
+elm_cxx_suite_CPPFLAGS = \
+	-DTESTS_BUILD_DIR=\"${top_builddir}/src/tests\" \
+	-DELM_IMAGE_DATA_DIR=\"${top_srcdir}/data\" \
+	-I$(top_srcdir)/src/lib \
+	-I$(top_builddir)/src/lib \
+	@CHECK_CFLAGS@ \
+	@ELEMENTARY_CFLAGS@ \
+	@ELEMENTARY_CXX_CFLAGS@
+
+elm_cxx_suite_LDADD = \
+	$(top_builddir)/src/lib/libelementary.la \
+	@CHECK_LIBS@ \
+	@ELEMENTARY_LIBS@
+endif
diff --git a/src/tests/elementary/elm_cxx_suite.cc b/src/tests/elementary/elm_cxx_suite.cc
new file mode 100644
index 0000000000..1e7a5d63a0
--- /dev/null
+++ b/src/tests/elementary/elm_cxx_suite.cc
@@ -0,0 +1,5 @@
+#include <Elementary.hh>
+
+int main()
+{
+}
diff --git a/src/tests/elementary/elm_suite.c b/src/tests/elementary/elm_suite.c
new file mode 100644
index 0000000000..bb9625fdfe
--- /dev/null
+++ b/src/tests/elementary/elm_suite.c
@@ -0,0 +1,123 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Elementary.h>
+#include "elm_suite.h"
+
+typedef struct _Elementary_Test_Case Elementary_Test_Case;
+
+struct _Elementary_Test_Case
+{
+   const char *test_case;
+   void      (*build)(TCase *tc);
+};
+
+static const Elementary_Test_Case etc[] = {
+  { "Elementary", elm_test_init },
+  { "elm_check", elm_test_check },
+  { "elm_colorselector", elm_test_colorselector },
+  { "elm_entry", elm_test_entry},
+  { "elm_atspi", elm_test_atspi},
+  { "elm_button", elm_test_button},
+  { "elm_image", elm_test_image},
+  { "elm_list", elm_test_list},
+  { "elm_photo", elm_test_photo},
+  { "elm_actionslider", elm_test_actionslider},
+  { "elm_box", elm_test_box},
+  { "elm_table", elm_test_table},
+  { "elm_thumb", elm_test_thumb},
+  { "elm_menu", elm_test_menu},
+  { "elm_photocam", elm_test_photocam},
+  { "elm_win", elm_test_win},
+  { "elm_icon", elm_test_icon},
+  { "elm_prefs", elm_test_prefs},
+  { "elm_map", elm_test_map},
+  { "elm_glview", elm_test_glview},
+  { "elm_web", elm_test_web},
+  { "elm_toolbar", elm_test_toolbar},
+  { "elm_grid", elm_test_grid},
+  { "elm_diskselector", elm_test_diskselector},
+  { "elm_notify", elm_test_notify},
+  { "elm_mapbuf", elm_test_mapbuf},
+  { "elm_flip", elm_test_flip},
+  { "elm_layout", elm_test_layout},
+  { "elm_slider", elm_test_slider},
+  { "elm_ctxpopup", elm_test_ctxpopup},
+  { "elm_separator", elm_test_separator},
+  { "elm_calendar", elm_test_calendar},
+  { "elm_inwin", elm_test_inwin},
+  { "elm_gengrid", elm_test_gengrid},
+  { "elm_radio", elm_test_radio},
+  { "elm_scroller", elm_test_scroller},
+  { "elm_frame", elm_test_frame},
+  { "elm_datetime", elm_test_datetime},
+  { "elm_player", elm_test_player},
+  { "elm_bg", elm_test_bg},
+  { "elm_video", elm_test_video},
+  { "elm_segmentcontrol", elm_test_segmentcontrol},
+  { "elm_progressbar", elm_test_progressbar},
+  { "elm_fileselector", elm_test_fileselector},
+  { "elm_fileselector_button", elm_test_fileselector_button},
+  { "elm_fileselector_entry", elm_test_fileselector_entry},
+  { "elm_hoversel", elm_test_hoversel},
+  { "elm_multibuttonentry", elm_test_multibuttonentry},
+  { "elm_naviframe", elm_test_naviframe},
+  { "elm_popup", elm_test_popup},
+  { "elm_bubble", elm_test_bubble},
+  { "elm_clock", elm_test_clock},
+  { "elm_conformant", elm_test_conformant},
+  { "elm_dayselector", elm_test_dayselector},
+  { "elm_flipselector", elm_test_flipselector},
+  { "elm_genlist", elm_test_genlist},
+  { "elm_hover", elm_test_hover},
+  { "elm_index", elm_test_index},
+  { "elm_label", elm_test_label},
+  { "elm_panel", elm_test_panel},
+  { "elm_panes", elm_test_panes},
+  { "elm_slideshow", elm_test_slideshow},
+  { "elm_spinner", elm_test_spinner},
+  { "elm_plug", elm_test_plug},
+  { NULL, NULL }
+};
+
+Suite *
+elm_suite()
+{
+   TCase *tc;
+   Suite *s;
+   int i;
+
+   s = suite_create("Elementary");
+
+   for (i = 0; etc[i].test_case; ++i)
+     {
+        tc = tcase_create(etc[i].test_case);
+        etc[i].build(tc);
+        suite_add_tcase(s, tc);
+        tcase_set_timeout(tc, 0);
+     }
+
+   return s;
+}
+
+int
+main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
+{
+   int failed_count;
+   Suite *s;
+   SRunner *sr;
+
+   putenv("ELM_RUN_IN_TREE=1");
+
+   s = elm_suite();
+   sr = srunner_create(s);
+
+   srunner_set_xml(sr, TESTS_BUILD_DIR "/check-results.xml");
+
+   srunner_run_all(sr, CK_ENV);
+   failed_count = srunner_ntests_failed(sr);
+   srunner_free(sr);
+
+   return (failed_count == 0) ? 0 : 255;
+}
diff --git a/src/tests/elementary/elm_suite.h b/src/tests/elementary/elm_suite.h
new file mode 100644
index 0000000000..1a191793bf
--- /dev/null
+++ b/src/tests/elementary/elm_suite.h
@@ -0,0 +1,72 @@
+#ifndef _ELM_SUITE_H
+#define _ELM_SUITE_H
+
+#include <check.h>
+#include "elm_test_helper.h"
+
+void elm_test_init(TCase *tc);
+void elm_test_check(TCase *tc);
+void elm_test_colorselector(TCase *tc);
+void elm_test_entry(TCase *tc);
+void elm_test_atspi(TCase *tc);
+void elm_test_button(TCase *tc);
+void elm_test_image(TCase *tc);
+void elm_test_list(TCase *tc);
+void elm_test_photo(TCase *tc);
+void elm_test_actionslider(TCase *tc);
+void elm_test_box(TCase *tc);
+void elm_test_table(TCase *tc);
+void elm_test_thumb(TCase *tc);
+void elm_test_menu(TCase *tc);
+void elm_test_photocam(TCase *tc);
+void elm_test_win(TCase *tc);
+void elm_test_icon(TCase *tc);
+void elm_test_prefs(TCase *tc);
+void elm_test_map(TCase *tc);
+void elm_test_glview(TCase *tc);
+void elm_test_web(TCase *tc);
+void elm_test_toolbar(TCase *tc);
+void elm_test_grid(TCase *tc);
+void elm_test_diskselector(TCase *tc);
+void elm_test_notify(TCase *tc);
+void elm_test_mapbuf(TCase *tc);
+void elm_test_flip(TCase *tc);
+void elm_test_layout(TCase *tc);
+void elm_test_slider(TCase *tc);
+void elm_test_ctxpopup(TCase *tc);
+void elm_test_separator(TCase *tc);
+void elm_test_calendar(TCase *tc);
+void elm_test_inwin(TCase *tc);
+void elm_test_gengrid(TCase *tc);
+void elm_test_radio(TCase *tc);
+void elm_test_scroller(TCase *tc);
+void elm_test_frame(TCase *tc);
+void elm_test_datetime(TCase *tc);
+void elm_test_player(TCase *tc);
+void elm_test_bg(TCase *tc);
+void elm_test_video(TCase *tc);
+void elm_test_segmentcontrol(TCase *tc);
+void elm_test_progressbar(TCase *tc);
+void elm_test_fileselector(TCase *tc);
+void elm_test_fileselector_button(TCase *tc);
+void elm_test_fileselector_entry(TCase *tc);
+void elm_test_hoversel(TCase *tc);
+void elm_test_multibuttonentry(TCase *tc);
+void elm_test_naviframe(TCase *tc);
+void elm_test_popup(TCase *tc);
+void elm_test_bubble(TCase *tc);
+void elm_test_clock(TCase *tc);
+void elm_test_conformant(TCase *tc);
+void elm_test_dayselector(TCase *tc);
+void elm_test_flipselector(TCase *tc);
+void elm_test_genlist(TCase *tc);
+void elm_test_hover(TCase *tc);
+void elm_test_index(TCase *tc);
+void elm_test_label(TCase *tc);
+void elm_test_panel(TCase *tc);
+void elm_test_panes(TCase *tc);
+void elm_test_slideshow(TCase *tc);
+void elm_test_spinner(TCase *tc);
+void elm_test_plug(TCase *tc);
+
+#endif /* _ELM_SUITE_H */
diff --git a/src/tests/elementary/elm_test_actionslider.c b/src/tests/elementary/elm_test_actionslider.c
new file mode 100644
index 0000000000..a6d7137fb0
--- /dev/null
+++ b/src/tests/elementary/elm_test_actionslider.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *actionslider;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "actionslider", ELM_WIN_BASIC);
+
+   actionslider = elm_actionslider_add(win);
+   role = elm_interface_atspi_accessible_role_get(actionslider);
+
+   ck_assert(role == ELM_ATSPI_ROLE_SLIDER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_actionslider(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_atspi.c b/src/tests/elementary/elm_test_atspi.c
new file mode 100644
index 0000000000..82c1564e37
--- /dev/null
+++ b/src/tests/elementary/elm_test_atspi.c
@@ -0,0 +1,509 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERNAL_API_ARGESFSDFEFC
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+
+#include <Elementary.h>
+#include "elm_priv.h"
+#include "elm_suite.h"
+
+static Evas_Object *g_win, *g_btn, *g_bg;
+
+void generate_app(void)
+{
+   g_win = elm_win_add(NULL, "Title", ELM_WIN_BASIC);
+   evas_object_geometry_set(g_win, 100, 100, 100, 100);
+
+   g_bg = elm_bg_add(g_win);
+
+   g_btn = elm_button_add(g_win);
+
+   evas_object_show(g_btn);
+   evas_object_show(g_bg);
+   evas_object_show(g_win);
+}
+
+START_TEST (elm_atspi_app_obj_name_get)
+{
+   elm_init(0, NULL);
+
+   Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
+
+   ck_assert(root != NULL);
+
+   const char *ret = NULL;
+
+   elm_app_name_set("Test name");
+
+   ret = elm_interface_atspi_accessible_name_get(root);
+
+   ck_assert_str_eq(ret, "Test name");
+
+   eo_unref(root);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_name_get)
+{
+   elm_init(0, NULL);
+   generate_app();
+
+   char *name;
+
+   name = elm_interface_atspi_accessible_name_get(g_btn);
+
+   if (name && name[0]) {
+      ck_assert(0);
+   }
+
+   free(name);
+
+   // Set name with additional text tags
+   elm_object_text_set(g_btn, "Some<br>text");
+
+   name = elm_interface_atspi_accessible_name_get(g_btn);
+
+   // Accessible name should have cleared tags
+   ck_assert(name != NULL);
+   ck_assert_str_eq(name, "Some\ntext");
+
+   free(name);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_name_set)
+{
+   elm_init(0, NULL);
+   generate_app();
+
+   char *name;
+
+   elm_object_text_set(g_btn, "Other text");
+   elm_interface_atspi_accessible_name_set(g_btn, "Test name");
+
+   name = elm_interface_atspi_accessible_name_get(g_btn);
+
+   ck_assert(name != NULL);
+   ck_assert_str_eq(name, "Test name");
+
+   free(name);
+
+   elm_interface_atspi_accessible_name_set(g_btn, NULL);
+   name = elm_interface_atspi_accessible_name_get(g_btn);
+
+   ck_assert(name != NULL);
+   ck_assert_str_eq(name, "Other text");
+
+   free(name);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_role_get)
+{
+   elm_init(0, NULL);
+
+   Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
+
+   Elm_Atspi_Role role;
+
+   role = elm_interface_atspi_accessible_role_get(root);
+
+   ck_assert(role == ELM_ATSPI_ROLE_APPLICATION);
+
+   eo_unref(root);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_role_set)
+{
+   elm_init(0, NULL);
+   generate_app();
+   Elm_Atspi_Role role;
+
+   elm_interface_atspi_accessible_role_set(g_btn, ELM_ATSPI_ROLE_ACCELERATOR_LABEL);
+   role = elm_interface_atspi_accessible_role_get(g_btn);
+
+   if (role != ELM_ATSPI_ROLE_ACCELERATOR_LABEL)
+      ck_assert(0);
+
+   elm_interface_atspi_accessible_role_set(g_btn, ELM_ATSPI_ROLE_ENTRY);
+   role = elm_interface_atspi_accessible_role_get(g_btn);
+
+   if (role != ELM_ATSPI_ROLE_ENTRY)
+      ck_assert(0);
+
+   elm_shutdown();
+}
+END_TEST
+
+
+
+START_TEST (elm_atspi_role_name_get)
+{
+   elm_init(0, NULL);
+
+   Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
+
+   const char *ret = NULL;
+
+   ret = elm_interface_atspi_accessible_role_name_get(root);
+
+   ck_assert(ret != NULL);
+
+   eo_unref(root);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_localized_role_name_get)
+{
+   elm_init(0, NULL);
+
+   Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
+
+   const char *ret = NULL;
+
+   ret = elm_interface_atspi_accessible_localized_role_name_get(root);
+
+   ck_assert(ret != NULL);
+
+   eo_unref(root);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_description_set)
+{
+   elm_init(0, NULL);
+
+   Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
+
+   const char *ret = NULL;
+
+   const char *desc = "Test description";
+
+   ret = elm_interface_atspi_accessible_description_get(root);
+
+   ck_assert(ret == NULL);
+
+   elm_interface_atspi_accessible_description_set(root, desc);
+   ret = elm_interface_atspi_accessible_description_get(root);
+
+   ck_assert(ret != NULL);
+   ck_assert_str_eq(ret, "Test description");
+
+   elm_interface_atspi_accessible_description_set(root, NULL);
+   ret = elm_interface_atspi_accessible_description_get(root);
+
+   ck_assert(ret == NULL);
+
+   eo_unref(root);
+   elm_shutdown();
+}
+END_TEST
+
+/* Test if initial description value is NULL */
+START_TEST (elm_atspi_description_get)
+{
+   elm_init(0, NULL);
+   generate_app();
+
+   const char *descr;
+   descr = elm_interface_atspi_accessible_description_get(g_bg);
+
+   ck_assert(descr == NULL);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_children_and_parent)
+{
+   elm_init(0, NULL);
+
+   generate_app();
+   Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
+
+   Eina_List *child_list = NULL;
+
+   child_list = elm_interface_atspi_accessible_children_get(root);
+
+   //bg_child_list = elm_interface_atspi_accessible_children_get(eina_list_nth(child_list, 0));
+
+   ck_assert(eina_list_count(child_list) == 1);
+
+   Eo *win = NULL;
+
+   win = eina_list_nth(child_list, 0);
+
+   ck_assert(win != NULL);
+   ck_assert(win == g_win);
+
+   eo_unref(root);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_children_and_parent2)
+{
+   elm_init(0, NULL);
+
+   generate_app();
+   Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
+
+   Eo *win = NULL;
+
+   Eina_List *root_children;
+   root_children = elm_interface_atspi_accessible_children_get(root);
+   win = eina_list_nth(root_children, 0);
+
+   Eina_List *win_children;
+   win_children = elm_interface_atspi_accessible_children_get(win);
+
+   ck_assert(eina_list_count(win_children) == 1);
+
+   Eo *btn = NULL;
+
+   btn = eina_list_nth(win_children, 0);
+   ck_assert(btn != NULL);
+   ck_assert(btn == g_btn);
+
+   eo_unref(root);
+   elm_shutdown();
+}
+END_TEST
+
+/* Initial value of translation domain should be NULL */
+START_TEST (elm_atspi_translation_domain_get)
+{
+   elm_init(0, NULL);
+   generate_app();
+
+   const char *domain;
+
+   domain = elm_interface_atspi_accessible_translation_domain_get(g_btn);
+
+   ck_assert(domain == NULL);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_translation_domain_set)
+{
+   elm_init(0, NULL);
+   generate_app();
+
+   const char *domain;
+
+   elm_interface_atspi_accessible_translation_domain_set(g_btn, "Test translation_domain");
+   domain = elm_interface_atspi_accessible_translation_domain_get(g_btn);
+
+   ck_assert(domain != NULL);
+   ck_assert_str_eq(domain, "Test translation_domain");
+
+   elm_interface_atspi_accessible_translation_domain_set(g_btn, NULL);
+   domain = elm_interface_atspi_accessible_translation_domain_get(g_btn);
+
+   ck_assert(domain == NULL);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_relationship_append)
+{
+   elm_init(0, NULL);
+   generate_app();
+
+   Elm_Atspi_Relation_Set set;
+   Elm_Atspi_Relation *rel, *rel_to, *rel_from;
+   Eina_List *l;
+
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_bg);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_FROM, g_win);
+   set = elm_interface_atspi_accessible_relation_set_get(g_btn);
+
+   ck_assert(set != NULL);
+   ck_assert(eina_list_count(set) >= 2);
+
+   rel_to = rel_from = NULL;
+   EINA_LIST_FOREACH(set, l, rel)
+   {
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_TO)
+        rel_to = rel;
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_FROM)
+        rel_from = rel;
+   }
+
+   ck_assert(rel_to != NULL);
+   ck_assert(eina_list_data_find(rel_to->objects, g_bg) != NULL);
+
+   ck_assert(rel_from != NULL);
+   ck_assert(eina_list_data_find(rel_from->objects, g_win) != NULL);
+
+   elm_atspi_relation_set_free(set);
+
+   /* Check if append do not procude duplicated relations */
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_bg);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_FROM, g_win);
+   set = elm_interface_atspi_accessible_relation_set_get(g_btn);
+
+   rel_to = rel_from = NULL;
+   EINA_LIST_FOREACH(set, l, rel)
+   {
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_TO)
+        rel_to = rel;
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_FROM)
+        rel_from = rel;
+   }
+
+   ck_assert(rel_to != NULL);
+   ck_assert(rel_to->objects != NULL);
+   rel_to->objects = eina_list_remove(rel_to->objects, g_bg);
+   ck_assert(eina_list_data_find(rel_to->objects, g_bg) == NULL);
+
+   ck_assert(rel_from != NULL);
+   ck_assert(rel_from->objects != NULL);
+   rel_from->objects = eina_list_remove(rel_from->objects, g_win);
+   ck_assert(eina_list_data_find(rel_from->objects, g_win) == NULL);
+
+   elm_atspi_relation_set_free(set);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_relationship_remove)
+{
+   elm_init(0, NULL);
+   generate_app();
+
+   Elm_Atspi_Relation_Set set;
+   Elm_Atspi_Relation *rel, *rel_to, *rel_from;
+   Eina_List *l;
+
+   /* Test if removal of single relationship works */
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_bg);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_FROM, g_win);
+   elm_interface_atspi_accessible_relationship_remove(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_bg);
+   set = elm_interface_atspi_accessible_relation_set_get(g_btn);
+
+   ck_assert(set != NULL);
+   ck_assert(eina_list_count(set) >= 1);
+
+   rel_to = rel_from = NULL;
+   EINA_LIST_FOREACH(set, l, rel)
+   {
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_TO)
+        rel_to = rel;
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_FROM)
+        rel_from = rel;
+   }
+
+   if (rel_to) ck_assert(eina_list_data_find(rel_to->objects, g_bg) == NULL);
+   ck_assert(rel_from != NULL);
+   ck_assert(eina_list_data_find(rel_from->objects, g_win) != NULL);
+
+   elm_atspi_relation_set_free(set);
+
+   /* Test if removal of type relationship works */
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_bg);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_win);
+   elm_interface_atspi_accessible_relationship_remove(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, NULL);
+   set = elm_interface_atspi_accessible_relation_set_get(g_btn);
+
+   rel_to = rel_from = NULL;
+   EINA_LIST_FOREACH(set, l, rel)
+   {
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_TO)
+        rel_to = rel;
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_FROM)
+        rel_from = rel;
+   }
+
+   ck_assert(rel_to == NULL);
+   ck_assert(rel_from != NULL);
+   ck_assert(eina_list_data_find(rel_from->objects, g_win) != NULL);
+
+   elm_atspi_relation_set_free(set);
+
+   /* Test if relationship is implicity removed when object is deleted */
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_bg);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_FROM, g_bg);
+   eo_del(g_bg);
+   set = elm_interface_atspi_accessible_relation_set_get(g_btn);
+
+   rel_to = rel_from = NULL;
+   EINA_LIST_FOREACH(set, l, rel)
+   {
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_TO)
+        rel_to = rel;
+      if (rel->type == ELM_ATSPI_RELATION_FLOWS_FROM)
+        rel_from = rel;
+   }
+
+   if (rel_to) ck_assert(eina_list_data_find(rel_to->objects, g_bg) == NULL);
+   if (rel_from) ck_assert(eina_list_data_find(rel_from->objects, g_bg) == NULL);
+
+   elm_atspi_relation_set_free(set);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_relationships_clear)
+{
+   Elm_Atspi_Relation_Set set;
+   Elm_Atspi_Relation *rel;
+   Eina_List *l;
+
+   elm_init(0, NULL);
+   generate_app();
+
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_bg);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_FROM, g_bg);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_TO, g_win);
+   elm_interface_atspi_accessible_relationship_append(g_btn, ELM_ATSPI_RELATION_FLOWS_FROM, g_win);
+
+   elm_interface_atspi_accessible_relationships_clear(g_btn);
+
+   set = elm_interface_atspi_accessible_relation_set_get(g_btn);
+   EINA_LIST_FOREACH(set, l, rel)
+   {
+      ck_assert(!((rel->type == ELM_ATSPI_RELATION_FLOWS_TO) && eina_list_data_find(rel->objects, g_bg)));
+      ck_assert(!((rel->type == ELM_ATSPI_RELATION_FLOWS_FROM) && eina_list_data_find(rel->objects, g_bg)));
+      ck_assert(!((rel->type == ELM_ATSPI_RELATION_FLOWS_TO) && eina_list_data_find(rel->objects, g_win)));
+      ck_assert(!((rel->type == ELM_ATSPI_RELATION_FLOWS_FROM) && eina_list_data_find(rel->objects, g_win)));
+   }
+
+   elm_atspi_relation_set_free(set);
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_atspi(TCase *tc)
+{
+   tcase_add_test(tc, elm_atspi_app_obj_name_get);
+   tcase_add_test(tc, elm_atspi_name_get);
+   tcase_add_test(tc, elm_atspi_name_set);
+   tcase_add_test(tc, elm_atspi_role_get);
+   tcase_add_test(tc, elm_atspi_role_set);
+   tcase_add_test(tc, elm_atspi_role_name_get);
+   tcase_add_test(tc, elm_atspi_localized_role_name_get);
+   tcase_add_test(tc, elm_atspi_description_set);
+   tcase_add_test(tc, elm_atspi_description_get);
+   tcase_add_test(tc, elm_atspi_children_and_parent);
+   tcase_add_test(tc, elm_atspi_children_and_parent2);
+   tcase_add_test(tc, elm_atspi_translation_domain_get);
+   tcase_add_test(tc, elm_atspi_translation_domain_set);
+   tcase_add_test(tc, elm_atspi_relationship_append);
+   tcase_add_test(tc, elm_atspi_relationship_remove);
+   tcase_add_test(tc, elm_atspi_relationships_clear);
+}
diff --git a/src/tests/elementary/elm_test_bg.c b/src/tests/elementary/elm_test_bg.c
new file mode 100644
index 0000000000..8c2047d7a2
--- /dev/null
+++ b/src/tests/elementary/elm_test_bg.c
@@ -0,0 +1,10 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Elementary.h>
+#include "elm_suite.h"
+
+void elm_test_bg(TCase *tc EINA_UNUSED)
+{
+}
diff --git a/src/tests/elementary/elm_test_box.c b/src/tests/elementary/elm_test_box.c
new file mode 100644
index 0000000000..eb14a53aa5
--- /dev/null
+++ b/src/tests/elementary/elm_test_box.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *box;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "box", ELM_WIN_BASIC);
+
+   box = elm_box_add(win);
+   role = elm_interface_atspi_accessible_role_get(box);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FILLER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_box(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_bubble.c b/src/tests/elementary/elm_test_bubble.c
new file mode 100644
index 0000000000..bbae3ce1d6
--- /dev/null
+++ b/src/tests/elementary/elm_test_bubble.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *bubble;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "bubble", ELM_WIN_BASIC);
+
+   bubble = elm_bubble_add(win);
+   role = elm_interface_atspi_accessible_role_get(bubble);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FILLER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_bubble(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
+
diff --git a/src/tests/elementary/elm_test_button.c b/src/tests/elementary/elm_test_button.c
new file mode 100644
index 0000000000..afa1cadd46
--- /dev/null
+++ b/src/tests/elementary/elm_test_button.c
@@ -0,0 +1,49 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#define ELM_INTERFACE_ATSPI_COMPONENT_PROTECTED
+#define ELM_INTERFACE_ATSPI_ACTION_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *button;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "button", ELM_WIN_BASIC);
+
+   button = elm_button_add(win);
+   role = elm_interface_atspi_accessible_role_get(button);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PUSH_BUTTON);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_interfaces_check)
+{
+   Evas_Object *win, *button;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "button", ELM_WIN_BASIC);
+
+   button = elm_button_add(win);
+
+   ck_assert(eo_isa(button, ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN));
+   ck_assert(eo_isa(button, ELM_INTERFACE_ATSPI_COMPONENT_MIXIN));
+   ck_assert(eo_isa(button, ELM_INTERFACE_ATSPI_ACTION_MIXIN));
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_button(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+ tcase_add_test(tc, elm_atspi_interfaces_check);
+}
diff --git a/src/tests/elementary/elm_test_calendar.c b/src/tests/elementary/elm_test_calendar.c
new file mode 100644
index 0000000000..433b5d14bc
--- /dev/null
+++ b/src/tests/elementary/elm_test_calendar.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *calendar;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "calendar", ELM_WIN_BASIC);
+
+   calendar = elm_calendar_add(win);
+   role = elm_interface_atspi_accessible_role_get(calendar);
+
+   ck_assert(role == ELM_ATSPI_ROLE_CALENDAR);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_calendar(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_check.c b/src/tests/elementary/elm_test_check.c
new file mode 100644
index 0000000000..8abfe3a05c
--- /dev/null
+++ b/src/tests/elementary/elm_test_check.c
@@ -0,0 +1,75 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_check_onoff_text)
+{
+   Evas_Object *win, *check;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "check", ELM_WIN_BASIC);
+
+   check = elm_check_add(win);
+   elm_object_style_set(check, "toggle");
+   elm_object_part_text_set(check, "on", "OnText");
+   elm_object_part_text_set(check, "off", "OffText");
+
+   ck_assert_str_eq(elm_object_part_text_get(check, "on"), "OnText");
+   ck_assert_str_eq(elm_object_part_text_get(check, "off"), "OffText");
+
+   elm_object_style_set(check, "default");
+   ck_assert(elm_object_part_text_get(check, "on") == NULL);
+   ck_assert(elm_object_part_text_get(check, "off") == NULL);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_check_state)
+{
+   Evas_Object *win, *check;
+   Eina_Bool state = EINA_TRUE;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "check", ELM_WIN_BASIC);
+
+   check = elm_check_add(win);
+   elm_check_state_pointer_set(check, &state);
+   ck_assert(elm_check_state_get(check) == EINA_TRUE);
+   ck_assert(state == EINA_TRUE);
+
+   elm_check_state_set(check, EINA_FALSE);
+   ck_assert(elm_check_state_get(check) == EINA_FALSE);
+   ck_assert(state == EINA_FALSE);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *check;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "check", ELM_WIN_BASIC);
+
+   check = elm_check_add(win);
+   role = elm_interface_atspi_accessible_role_get(check);
+
+   ck_assert(role == ELM_ATSPI_ROLE_CHECK_BOX);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_check(TCase *tc)
+{
+   tcase_add_test(tc, elm_check_onoff_text);
+   tcase_add_test(tc, elm_check_state);
+   tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_clock.c b/src/tests/elementary/elm_test_clock.c
new file mode 100644
index 0000000000..713858d718
--- /dev/null
+++ b/src/tests/elementary/elm_test_clock.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *clk;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "clock", ELM_WIN_BASIC);
+
+   clk = elm_clock_add(win);
+   role = elm_interface_atspi_accessible_role_get(clk);
+
+   ck_assert(role == ELM_ATSPI_ROLE_TEXT);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_clock(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
+
diff --git a/src/tests/elementary/elm_test_colorselector.c b/src/tests/elementary/elm_test_colorselector.c
new file mode 100644
index 0000000000..321f3df03d
--- /dev/null
+++ b/src/tests/elementary/elm_test_colorselector.c
@@ -0,0 +1,57 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_colorselector_palette)
+{
+   Evas_Object *win, *c;
+   unsigned int palette_cnt;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "check", ELM_WIN_BASIC);
+
+   c = elm_colorselector_add(win);
+   /* Get the count of default palettes */
+   palette_cnt = eina_list_count(elm_colorselector_palette_items_get(c));
+   evas_object_del(c);
+
+   c = elm_colorselector_add(win);
+   ck_assert(eina_list_count(elm_colorselector_palette_items_get(c)) == palette_cnt);
+   elm_colorselector_palette_color_add(c, 255, 255, 255, 255);
+   ck_assert(eina_list_count(elm_colorselector_palette_items_get(c)) == 1);
+   evas_object_del(c);
+
+   c = elm_colorselector_add(win);
+   ck_assert(eina_list_count(elm_colorselector_palette_items_get(c)) == palette_cnt);
+   evas_object_del(c);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *c;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "colorselector", ELM_WIN_BASIC);
+
+   c = elm_colorselector_add(win);
+   role = elm_interface_atspi_accessible_role_get(c);
+
+   ck_assert(role == ELM_ATSPI_ROLE_COLOR_CHOOSER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_colorselector(TCase *tc)
+{
+   tcase_add_test(tc, elm_colorselector_palette);
+   tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_conformant.c b/src/tests/elementary/elm_test_conformant.c
new file mode 100644
index 0000000000..a646e5ecb9
--- /dev/null
+++ b/src/tests/elementary/elm_test_conformant.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *conformant;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "conformant", ELM_WIN_BASIC);
+
+   conformant = elm_conformant_add(win);
+   role = elm_interface_atspi_accessible_role_get(conformant);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FILLER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_conformant(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_ctxpopup.c b/src/tests/elementary/elm_test_ctxpopup.c
new file mode 100644
index 0000000000..5c5ed6f9cc
--- /dev/null
+++ b/src/tests/elementary/elm_test_ctxpopup.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *ctxpopup;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "icon", ELM_WIN_BASIC);
+
+   ctxpopup = elm_ctxpopup_add(win);
+   role = elm_interface_atspi_accessible_role_get(ctxpopup);
+
+   ck_assert(role == ELM_ATSPI_ROLE_POPUP_MENU);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_ctxpopup(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_datetime.c b/src/tests/elementary/elm_test_datetime.c
new file mode 100644
index 0000000000..0935f88667
--- /dev/null
+++ b/src/tests/elementary/elm_test_datetime.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *datetime;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "datetime", ELM_WIN_BASIC);
+
+   datetime = elm_datetime_add(win);
+   role = elm_interface_atspi_accessible_role_get(datetime);
+
+   ck_assert(role == ELM_ATSPI_ROLE_DATE_EDITOR);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_datetime(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_dayselector.c b/src/tests/elementary/elm_test_dayselector.c
new file mode 100644
index 0000000000..d4f0288782
--- /dev/null
+++ b/src/tests/elementary/elm_test_dayselector.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *dayselector;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "dayselector", ELM_WIN_BASIC);
+
+   dayselector = elm_dayselector_add(win);
+   role = elm_interface_atspi_accessible_role_get(dayselector);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PANEL);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_dayselector(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
+
diff --git a/src/tests/elementary/elm_test_diskselector.c b/src/tests/elementary/elm_test_diskselector.c
new file mode 100644
index 0000000000..e902939d5a
--- /dev/null
+++ b/src/tests/elementary/elm_test_diskselector.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *diskselector;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "diskselector", ELM_WIN_BASIC);
+
+   diskselector = elm_diskselector_add(win);
+   role = elm_interface_atspi_accessible_role_get(diskselector);
+
+   ck_assert(role == ELM_ATSPI_ROLE_LIST);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_diskselector(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_entry.c b/src/tests/elementary/elm_test_entry.c
new file mode 100644
index 0000000000..ea898572ee
--- /dev/null
+++ b/src/tests/elementary/elm_test_entry.c
@@ -0,0 +1,362 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_TEXT_PROTECTED
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_entry_del)
+{
+   Evas_Object *win, *entry;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, "TEST");
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_char_get)
+{
+   Evas_Object *win, *entry;
+   Eina_Unicode *expected;
+   Eina_Unicode val;
+
+   const char *txt = "ĄA11Y Ł TEST";
+   const char *mtxt = "<b>ĄA11Y</b> <title>Ł</> TEST";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, mtxt);
+
+   expected = eina_unicode_utf8_to_unicode(txt, NULL);
+
+   val = elm_interface_atspi_text_character_get(entry, -1);
+   ck_assert(val == 0);
+
+   val = elm_interface_atspi_text_character_get(entry, 0);
+   ck_assert(val == expected[0]);
+
+   val = elm_interface_atspi_text_character_get(entry, 1);
+   ck_assert(val == expected[1]);
+
+   val = elm_interface_atspi_text_character_get(entry, 2);
+   ck_assert(val == expected[2]);
+
+   val = elm_interface_atspi_text_character_get(entry, 6);
+   ck_assert(val == expected[6]);
+
+   val = elm_interface_atspi_text_character_get(entry, 26);
+   ck_assert(val == 0);
+
+   free(expected);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_char_count)
+{
+   Evas_Object *win, *entry;
+   int val;
+
+   const char *mtxt = "<b>AĄ11Y</b> <title>Ł</> TEST";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, mtxt);
+
+   val = elm_interface_atspi_text_character_count_get(entry);
+   ck_assert(val == 12);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_string_get_char)
+{
+   Evas_Object *win, *entry;
+   char *val;
+   int start, end;
+
+   const char *txt = "Lorem ipśum   dolor sit amęt";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, txt);
+
+   start = 1;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_CHAR, &start, &end);
+   ck_assert_str_eq(val, "o");
+   ck_assert(start == 1);
+   ck_assert(end == 2);
+   if (val) free(val);
+
+   start = 8;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_CHAR, &start, &end);
+   ck_assert_str_eq(val, "ś");
+   ck_assert(start == 8);
+   ck_assert(end == 9);
+   if (val) free(val);
+
+   start = 11;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_CHAR, &start, &end);
+   ck_assert_str_eq(val, " ");
+   ck_assert(start == 11);
+   ck_assert(end == 12);
+   if (val) free(val);
+
+   start = 111;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_CHAR, &start, &end);
+   ck_assert(start == -1);
+   ck_assert(end == -1);
+   ck_assert(val == NULL);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_string_get_word)
+{
+   Evas_Object *win, *entry;
+   char *val;
+   int start, end;
+
+   const char *txt = "Lorem ipśum   dolor sit amęt";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, txt);
+
+   start = 1;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_WORD, &start, &end);
+   ck_assert_str_eq(val, "Lorem");
+   ck_assert(start == 0);
+   ck_assert(end == 5);
+   if (val) free(val);
+
+   start = 6;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_WORD, &start, &end);
+   ck_assert_str_eq(val, "ipśum");
+   ck_assert(start == 6);
+   ck_assert(end == 11);
+   if (val) free(val);
+
+   start = 19;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_WORD, &start, &end);
+   ck_assert_str_eq(val, "dolor");
+   ck_assert(start == 14);
+   ck_assert(end == 19);
+   if (val) free(val);
+
+   start = 111;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_WORD, &start, &end);
+   ck_assert(start == -1);
+   ck_assert(end == -1);
+   ck_assert(val == NULL);
+   if (val) free(val);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_string_get_paragraph)
+{
+   Evas_Object *win, *entry;
+   char *val;
+   int start, end;
+
+   const char *txt = "Lorem ipśum<br>   dolor sit<br> amęt";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, txt);
+
+   start = 1;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_PARAGRAPH, &start, &end);
+   ck_assert_str_eq(val, "Lorem ipśum");
+   ck_assert(start == 0);
+   ck_assert(end == 11);
+   if (val) free(val);
+
+   start = 20;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_PARAGRAPH, &start, &end);
+   ck_assert_str_eq(val, "   dolor sit");
+   ck_assert(start == 12);
+   ck_assert(end == 24);
+   if (val) free(val);
+
+   start = 25;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_PARAGRAPH, &start, &end);
+   ck_assert_str_eq(val, " amęt");
+   ck_assert(start == 25);
+   ck_assert(end == 30);
+   if (val) free(val);
+
+   start = 111;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_WORD, &start, &end);
+   ck_assert(start == -1);
+   ck_assert(end == -1);
+   ck_assert(val == NULL);
+   if (val) free(val);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_string_get_line)
+{
+   Evas_Object *win, *entry;
+   char *val;
+   int start, end;
+
+   const char *txt = "Lorem ipśum<br>   dolor sit amęt";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   evas_object_resize(entry, 500, 500);
+
+   elm_object_text_set(entry, txt);
+
+   start = 1;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_LINE, &start, &end);
+
+   ck_assert_str_eq(val, "Lorem ipśum");
+   ck_assert(start == 0);
+   ck_assert(end == 11);
+   if (val) free(val);
+
+   start = 13;
+   val = elm_interface_atspi_text_string_get(entry, ELM_ATSPI_TEXT_GRANULARITY_LINE, &start, &end);
+   ck_assert_str_eq(val, "   dolor sit amęt");
+   ck_assert(start == 12);
+   ck_assert(end == 29);
+   if (val) free(val);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_text_get)
+{
+   Evas_Object *win, *entry;
+   char *val;
+   const char *txt = "Lorem Xpśum dolor sit amęt";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, txt);
+
+   // invalid ranges
+   val = elm_interface_atspi_text_get(entry, 6, 100);
+   ck_assert(val == NULL);
+   val = elm_interface_atspi_text_get(entry, -6, 10);
+   ck_assert(val == NULL);
+   val = elm_interface_atspi_text_get(entry, -6, -10);
+   ck_assert(val == NULL);
+   val = elm_interface_atspi_text_get(entry, 60, 100);
+   ck_assert(val == NULL);
+
+   // proper range
+   val = elm_interface_atspi_text_get(entry, 6, 17);
+   ck_assert_str_eq(val, "Xpśum dolor");
+
+   if (val) free(val);
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_entry_atspi_text_selections)
+{
+   Evas_Object *win, *entry;
+   int val, start, end;
+   const char *str;
+   Eina_Bool ret;
+   const char *txt = "Lorem ipśum<br>   dolor sit\n amęt";
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   elm_object_text_set(entry, txt);
+
+   val = elm_interface_atspi_text_selections_count_get(entry);
+   ck_assert(val == 0);
+
+   elm_entry_select_region_set(entry, 2, 4);
+   val = elm_interface_atspi_text_selections_count_get(entry);
+   ck_assert(val == 1);
+   elm_interface_atspi_text_selection_get(entry, 0, &start, &end);
+   ck_assert(start == 2);
+   ck_assert(end == 4);
+
+   elm_entry_select_region_set(entry, 6, 10);
+   val = elm_interface_atspi_text_selections_count_get(entry);
+   ck_assert(val == 1);
+   elm_interface_atspi_text_selection_get(entry, 0, &start, &end);
+   ck_assert(start == 6);
+   ck_assert(end == 10);
+
+   elm_entry_select_none(entry);
+   ret = elm_interface_atspi_text_selection_add(entry, 2, 5);
+   ck_assert(ret == EINA_TRUE);
+   str = elm_entry_selection_get(entry);
+   ck_assert_str_eq(str, "rem");
+
+   ret = elm_interface_atspi_text_selection_remove(entry, 0);
+   ck_assert(ret == EINA_TRUE);
+   str = elm_entry_selection_get(entry);
+   ck_assert(str == NULL);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *entry;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "entry", ELM_WIN_BASIC);
+
+   entry = elm_entry_add(win);
+   role = elm_interface_atspi_accessible_role_get(entry);
+
+   ck_assert(role == ELM_ATSPI_ROLE_ENTRY);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_entry(TCase *tc)
+{
+   tcase_add_test(tc, elm_entry_del);
+   tcase_add_test(tc, elm_entry_atspi_text_char_get);
+   tcase_add_test(tc, elm_entry_atspi_text_char_count);
+   tcase_add_test(tc, elm_entry_atspi_text_string_get_char);
+   tcase_add_test(tc, elm_entry_atspi_text_string_get_word);
+   tcase_add_test(tc, elm_entry_atspi_text_string_get_paragraph);
+   tcase_add_test(tc, elm_entry_atspi_text_string_get_line);
+   tcase_add_test(tc, elm_entry_atspi_text_text_get);
+   tcase_add_test(tc, elm_entry_atspi_text_selections);
+   tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_fileselector.c b/src/tests/elementary/elm_test_fileselector.c
new file mode 100644
index 0000000000..4a86d999a6
--- /dev/null
+++ b/src/tests/elementary/elm_test_fileselector.c
@@ -0,0 +1,92 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *fileselector;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "fileselector", ELM_WIN_BASIC);
+
+   fileselector = elm_fileselector_add(win);
+   role = elm_interface_atspi_accessible_role_get(fileselector);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FILE_CHOOSER);
+
+   elm_shutdown();
+}
+END_TEST
+
+static void
+_directory_open_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+    Eina_Bool *ret = data;
+    *ret = EINA_TRUE;
+}
+
+START_TEST (elm_fileselector_selected)
+{
+   Evas_Object *win, *fileselector;
+   Eina_Tmpstr *tmp_path;
+   Eina_Stringshare *exist, *no_exist;
+   FILE *fp;
+   char *path;
+   Eina_Bool selected;
+
+   elm_init(1, NULL);
+
+   if (!eina_file_mkdtemp("elm_test-XXXXXX", &tmp_path))
+     {
+        /* can not test */
+        ck_assert(EINA_FALSE);
+        return;
+     }
+
+   path = strdup(tmp_path);
+   eina_tmpstr_del(tmp_path);
+
+   exist = eina_stringshare_printf("%s/exist", path);
+   no_exist = eina_stringshare_printf("%s/no_exist", path);
+   fp = fopen(exist, "w");
+   fclose(fp);
+
+   win = elm_win_add(NULL, "fileselector", ELM_WIN_BASIC);
+
+   fileselector = elm_fileselector_add(win);
+   evas_object_smart_callback_add(fileselector, "directory,open", _directory_open_cb, &selected);
+
+   ck_assert(!elm_fileselector_selected_set(fileselector, no_exist));
+
+   selected = EINA_FALSE;
+   ck_assert(elm_fileselector_selected_set(fileselector, path));
+   ck_assert(elm_test_helper_wait_flag(10, &selected));
+
+   ck_assert_str_eq(elm_fileselector_selected_get(fileselector), path);
+
+   selected = EINA_FALSE;
+   ck_assert(elm_fileselector_selected_set(fileselector, exist));
+   ck_assert(elm_test_helper_wait_flag(10, &selected));
+
+   ck_assert_str_eq(elm_fileselector_selected_get(fileselector), exist);
+
+   eina_stringshare_del(exist);
+   eina_stringshare_del(no_exist);
+   free(path);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_fileselector(TCase *tc)
+{
+   tcase_add_test(tc, elm_atspi_role_get);
+   tcase_add_test(tc, elm_fileselector_selected);
+}
+
diff --git a/src/tests/elementary/elm_test_fileselector_button.c b/src/tests/elementary/elm_test_fileselector_button.c
new file mode 100644
index 0000000000..653678d9dd
--- /dev/null
+++ b/src/tests/elementary/elm_test_fileselector_button.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *fs_button;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "fileselector_button", ELM_WIN_BASIC);
+
+   fs_button = elm_fileselector_button_add(win);
+   role = elm_interface_atspi_accessible_role_get(fs_button);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PUSH_BUTTON);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_fileselector_button(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_fileselector_entry.c b/src/tests/elementary/elm_test_fileselector_entry.c
new file mode 100644
index 0000000000..d78cf1b239
--- /dev/null
+++ b/src/tests/elementary/elm_test_fileselector_entry.c
@@ -0,0 +1,29 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *fs_entry;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "fileselectorentry", ELM_WIN_BASIC);
+
+   fs_entry = elm_fileselector_entry_add(win);
+   role = elm_interface_atspi_accessible_role_get(fs_entry);
+
+   ck_assert(role == ELM_ATSPI_ROLE_GROUPING);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_fileselector_entry(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_flip.c b/src/tests/elementary/elm_test_flip.c
new file mode 100644
index 0000000000..947c020ddc
--- /dev/null
+++ b/src/tests/elementary/elm_test_flip.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *flip;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "flip", ELM_WIN_BASIC);
+
+   flip = elm_flip_add(win);
+   role = elm_interface_atspi_accessible_role_get(flip);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PAGE_TAB_LIST);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_flip(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_flipselector.c b/src/tests/elementary/elm_test_flipselector.c
new file mode 100644
index 0000000000..2ede134a04
--- /dev/null
+++ b/src/tests/elementary/elm_test_flipselector.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *flipselector;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "flipselector", ELM_WIN_BASIC);
+
+   flipselector = elm_flipselector_add(win);
+   role = elm_interface_atspi_accessible_role_get(flipselector);
+
+   ck_assert(role == ELM_ATSPI_ROLE_LIST);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_flipselector(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_frame.c b/src/tests/elementary/elm_test_frame.c
new file mode 100644
index 0000000000..2527544a39
--- /dev/null
+++ b/src/tests/elementary/elm_test_frame.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *frame;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "frame", ELM_WIN_BASIC);
+
+   frame = elm_frame_add(win);
+   role = elm_interface_atspi_accessible_role_get(frame);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FRAME);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_frame(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_gengrid.c b/src/tests/elementary/elm_test_gengrid.c
new file mode 100644
index 0000000000..54e37e20c2
--- /dev/null
+++ b/src/tests/elementary/elm_test_gengrid.c
@@ -0,0 +1,83 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+#include "elm_test_helper.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *gengrid;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "gengrid", ELM_WIN_BASIC);
+
+   gengrid = elm_gengrid_add(win);
+   role = elm_interface_atspi_accessible_role_get(gengrid);
+
+   ck_assert(role == ELM_ATSPI_ROLE_TREE_TABLE);
+
+   elm_shutdown();
+}
+END_TEST
+
+// Temporary commnted since gengrid fields_update function do not call content callbacks
+// (different behaviour then genlist - which calls)
+#if 0
+static Evas_Object *content;
+
+static Evas_Object *
+gl_content_get(void *data EINA_UNUSED, Evas_Object *obj, const char *part EINA_UNUSED)
+{
+   content = elm_button_add(obj);
+   evas_object_show(content);
+   return content;
+}
+
+/**
+ * Validate if gengrid implementation properly reset AT-SPI parent to Elm_Gengrid_Item
+ * from Elm_Gengrid
+ */
+START_TEST(elm_atspi_children_parent)
+{
+   elm_init(1, NULL);
+   elm_config_atspi_mode_set(EINA_TRUE);
+   static Elm_Gengrid_Item_Class itc;
+
+   Evas_Object *win = elm_win_add(NULL, "gengrid", ELM_WIN_BASIC);
+   evas_object_resize(win, 100, 100);
+   Evas_Object *gengrid = elm_gengrid_add(win);
+   evas_object_resize(gengrid, 100, 100);
+
+   Elm_Interface_Atspi_Accessible *parent;
+   content = NULL;
+
+   itc.item_style = "default";
+   itc.func.content_get = gl_content_get;
+
+   evas_object_show(win);
+   evas_object_show(gengrid);
+
+   Elm_Object_Item *it = elm_gengrid_item_append(gengrid, &itc, NULL, NULL, NULL);
+   elm_gengrid_item_fields_update(it, "*.", ELM_GENGRID_ITEM_FIELD_CONTENT);
+
+   ck_assert(content != NULL);
+   parent = elm_interface_atspi_accessible_parent_get(content);
+   ck_assert(it == parent);
+
+   elm_shutdown();
+}
+END_TEST
+#endif
+
+void elm_test_gengrid(TCase *tc)
+{
+   tcase_add_test(tc, elm_atspi_role_get);
+#if 0
+   tcase_add_test(tc, elm_atspi_children_parent);
+#endif
+}
diff --git a/src/tests/elementary/elm_test_genlist.c b/src/tests/elementary/elm_test_genlist.c
new file mode 100644
index 0000000000..614fda9cc2
--- /dev/null
+++ b/src/tests/elementary/elm_test_genlist.c
@@ -0,0 +1,190 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+static Evas_Object *win, *genlist;
+static Elm_Gen_Item_Class itc;
+static Eo *current;
+static int counter;
+static Elm_Atspi_Event_Children_Changed_Data ev_data;
+Evas_Object *content;
+
+
+void test_init(void)
+{
+   elm_init(1, NULL);
+   elm_config_atspi_mode_set(EINA_TRUE);
+   win = elm_win_add(NULL, "genlist", ELM_WIN_BASIC);
+   genlist = elm_genlist_add(win);
+}
+
+START_TEST (elm_atspi_role_get)
+{
+   test_init();
+
+   Elm_Atspi_Role role;
+
+   role = elm_interface_atspi_accessible_role_get(genlist);
+
+   ck_assert(role == ELM_ATSPI_ROLE_LIST);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST(elm_atspi_children_get1)
+{
+   test_init();
+   Eina_List *children;
+   Elm_Object_Item *it[3];
+
+   children = elm_interface_atspi_accessible_children_get(genlist);
+   ck_assert(children == NULL);
+
+   it[0] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+   it[1] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+   it[2] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+
+   children = elm_interface_atspi_accessible_children_get(genlist);
+   ck_assert(eina_list_count(children) == 3);
+   ck_assert(eina_list_nth(children, 0) == it[0]);
+   ck_assert(eina_list_nth(children, 1) == it[1]);
+   ck_assert(eina_list_nth(children, 2) == it[2]);
+
+   eina_list_free(children);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST(elm_atspi_children_get2)
+{
+   test_init();
+   Eina_List *children;
+   Elm_Object_Item *it[3];
+
+   it[0] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+   it[1] = elm_genlist_item_prepend(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_GROUP, NULL, NULL);
+   it[2] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_TREE, NULL, NULL);
+
+   children = elm_interface_atspi_accessible_children_get(genlist);
+   ck_assert(eina_list_nth(children, 1) == it[0]);
+   ck_assert(eina_list_nth(children, 0) == it[1]);
+   ck_assert(eina_list_nth(children, 2) == it[2]);
+
+   elm_shutdown();
+}
+END_TEST
+
+static Eina_Bool
+_children_changed_cb(void *data EINA_UNUSED, const Eo_Event *event)
+{
+   if (event->desc != ELM_INTERFACE_ATSPI_ACCESSIBLE_EVENT_CHILDREN_CHANGED)
+     return EINA_TRUE;
+
+   ev_data = *(Elm_Atspi_Event_Children_Changed_Data*)event->event_info;
+   current = event->obj;
+   counter++;
+
+   return EINA_TRUE;
+}
+
+START_TEST(elm_atspi_children_events_add)
+{
+   test_init();
+
+   current = NULL;
+   counter = 0;
+
+   Elm_Object_Item *it[3];
+
+   elm_interface_atspi_accessible_event_handler_add(ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN, _children_changed_cb, NULL);
+
+   it[0] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+   ck_assert(genlist == current);
+   ck_assert(counter == 1);
+   ck_assert(ev_data.is_added == EINA_TRUE);
+   ck_assert(ev_data.child == it[0]);
+
+   it[1] = elm_genlist_item_prepend(genlist, &itc, it[0], NULL, ELM_GENLIST_ITEM_GROUP, NULL, NULL);
+   ck_assert(genlist == current);
+   ck_assert(counter == 2);
+   ck_assert(ev_data.is_added == EINA_TRUE);
+   ck_assert(ev_data.child == it[1]);
+
+   it[2] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_TREE, NULL, NULL);
+   ck_assert(genlist == current);
+   ck_assert(counter == 3);
+   ck_assert(ev_data.is_added == EINA_TRUE);
+   ck_assert(ev_data.child == it[2]);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST(elm_atspi_children_events_del1)
+{
+   test_init();
+
+   current = NULL;
+   counter = 0;
+
+   Elm_Object_Item *it[3];
+
+   it[0] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+   it[1] = elm_genlist_item_prepend(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+   it[2] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_TREE, NULL, NULL);
+
+   elm_interface_atspi_accessible_event_handler_add(ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN, _children_changed_cb, NULL);
+
+   elm_object_item_del(it[0]);
+   ck_assert(genlist == current);
+   ck_assert(counter == 1);
+   ck_assert(ev_data.is_added == EINA_FALSE);
+   ck_assert(ev_data.child == it[0]);
+
+   elm_object_item_del(it[2]);
+   ck_assert(genlist == current);
+   ck_assert(counter == 2);
+   ck_assert(ev_data.is_added == EINA_FALSE);
+   ck_assert(ev_data.child == it[2]);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST(elm_atspi_children_events_del2)
+{
+   test_init();
+
+   Elm_Object_Item *it;
+   current = NULL;
+   counter = 0;
+
+   it = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+
+   elm_interface_atspi_accessible_event_handler_add(ELM_INTERFACE_ATSPI_ACCESSIBLE_MIXIN, _children_changed_cb, NULL);
+   elm_genlist_clear(genlist);
+
+   ck_assert(genlist == current);
+   ck_assert(counter == 1);
+   ck_assert(ev_data.is_added == EINA_FALSE);
+   ck_assert(ev_data.child == it);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_genlist(TCase *tc)
+{
+   tcase_add_test(tc, elm_atspi_role_get);
+   tcase_add_test(tc, elm_atspi_children_get1);
+   tcase_add_test(tc, elm_atspi_children_get2);
+   tcase_add_test(tc, elm_atspi_children_events_add);
+   tcase_add_test(tc, elm_atspi_children_events_del1);
+   tcase_add_test(tc, elm_atspi_children_events_del2);
+}
diff --git a/src/tests/elementary/elm_test_glview.c b/src/tests/elementary/elm_test_glview.c
new file mode 100644
index 0000000000..556c22f6ee
--- /dev/null
+++ b/src/tests/elementary/elm_test_glview.c
@@ -0,0 +1,34 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *glview;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "glview", ELM_WIN_BASIC);
+
+   glview = elm_glview_add(win);
+
+   // if no gl backend skip test
+   if (glview)
+     {
+        role = elm_interface_atspi_accessible_role_get(glview);
+        ck_assert(role == ELM_ATSPI_ROLE_ANIMATION);
+     }
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_glview(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_grid.c b/src/tests/elementary/elm_test_grid.c
new file mode 100644
index 0000000000..f1350d49e6
--- /dev/null
+++ b/src/tests/elementary/elm_test_grid.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *grid;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "grid", ELM_WIN_BASIC);
+
+   grid = elm_grid_add(win);
+   role = elm_interface_atspi_accessible_role_get(grid);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FILLER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_grid(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_helper.c b/src/tests/elementary/elm_test_helper.c
new file mode 100644
index 0000000000..81ab0d1d23
--- /dev/null
+++ b/src/tests/elementary/elm_test_helper.c
@@ -0,0 +1,45 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Ecore.h>
+#include "elm_suite.h"
+
+static Eina_Bool
+timer_expired_cb(void *user_data)
+{
+   Eina_Bool *did_timeout = user_data;
+
+   *did_timeout = EINA_TRUE;
+   ecore_main_loop_quit();
+
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+idler_done_cb(void *user_data)
+{
+   Eina_Bool *done = user_data;
+
+   if (*done) ecore_main_loop_quit();
+
+   return EINA_TRUE;
+}
+
+Eina_Bool
+elm_test_helper_wait_flag(double in, Eina_Bool *done)
+{
+   Eina_Bool did_timeout = EINA_FALSE;
+   Ecore_Timer *tm;
+   Ecore_Idle_Enterer *idle;
+
+   tm = ecore_timer_add(in, timer_expired_cb, &did_timeout);
+   idle = ecore_idle_enterer_add(idler_done_cb, done);
+
+   ecore_main_loop_begin();
+
+   ecore_idle_enterer_del(idle);
+   ecore_timer_del(tm);
+
+   return !did_timeout;
+}
diff --git a/src/tests/elementary/elm_test_helper.h b/src/tests/elementary/elm_test_helper.h
new file mode 100644
index 0000000000..0bfc5ca0e6
--- /dev/null
+++ b/src/tests/elementary/elm_test_helper.h
@@ -0,0 +1,8 @@
+#ifndef _ELM_TEST_HELPER_H
+#define _ELM_TEST_HELPER_H
+
+#include <Eina.h>
+
+Eina_Bool elm_test_helper_wait_flag(double in, Eina_Bool *done);
+
+#endif /* _ELM_TEST_HELPER_H */
diff --git a/src/tests/elementary/elm_test_hover.c b/src/tests/elementary/elm_test_hover.c
new file mode 100644
index 0000000000..b23f892112
--- /dev/null
+++ b/src/tests/elementary/elm_test_hover.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *hover;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "hover", ELM_WIN_BASIC);
+
+   hover = elm_hover_add(win);
+   role = elm_interface_atspi_accessible_role_get(hover);
+
+   ck_assert(role == ELM_ATSPI_ROLE_POPUP_MENU);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_hover(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_hoversel.c b/src/tests/elementary/elm_test_hoversel.c
new file mode 100644
index 0000000000..14f1148b55
--- /dev/null
+++ b/src/tests/elementary/elm_test_hoversel.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *hoversel;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "hoversel", ELM_WIN_BASIC);
+
+   hoversel = elm_hoversel_add(win);
+   role = elm_interface_atspi_accessible_role_get(hoversel);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PUSH_BUTTON);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_hoversel(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_icon.c b/src/tests/elementary/elm_test_icon.c
new file mode 100644
index 0000000000..7cc9469d81
--- /dev/null
+++ b/src/tests/elementary/elm_test_icon.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *icon;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "icon", ELM_WIN_BASIC);
+
+   icon = elm_icon_add(win);
+   role = elm_interface_atspi_accessible_role_get(icon);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_icon(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_image.c b/src/tests/elementary/elm_test_image.c
new file mode 100644
index 0000000000..ef631c7d29
--- /dev/null
+++ b/src/tests/elementary/elm_test_image.c
@@ -0,0 +1,168 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+static const char pathfmt[] =  ELM_IMAGE_DATA_DIR"/images/icon_%02d.png";
+static const char invalid[] = "thereisnosuchimage.png";
+#define MAX_IMAGE_ID 23
+
+typedef struct _Test_Data Test_Data;
+struct _Test_Data
+{
+   int image_id;
+   Eina_Bool success;
+};
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *image;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "image", ELM_WIN_BASIC);
+
+   image = elm_image_add(win);
+   role = elm_interface_atspi_accessible_role_get(image);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE);
+
+   elm_shutdown();
+}
+END_TEST
+
+static Eina_Bool
+_async_error_cb(void *data, const Eo_Event *event)
+{
+   Test_Data *td = data;
+   char path[PATH_MAX];
+   sprintf(path, pathfmt, td->image_id);
+   efl_file_set(event->obj, path, NULL);
+   return EO_CALLBACK_CONTINUE;
+}
+
+static Eina_Bool
+_async_opened_cb(void *data, const Eo_Event *event)
+{
+   Test_Data *td = data;
+   const char *ff, *kk, *r1, *r2;
+   char path[PATH_MAX];
+
+   sprintf(path, pathfmt, td->image_id);
+   efl_file_get(event->obj, &ff, &kk);
+   r1 = strrchr(ff, '/');
+   r2 = strrchr(path, '/');
+   ck_assert(!strcmp(r1, r2));
+   ck_assert(!kk);
+
+   if (td->image_id < MAX_IMAGE_ID / 2)
+     {
+        td->image_id++;
+        sprintf(path, pathfmt, td->image_id);
+        efl_file_set(event->obj, path, NULL);
+        return EO_CALLBACK_CONTINUE;
+     }
+   else if (td->image_id < MAX_IMAGE_ID)
+     {
+        // mini stress-test
+        for (; td->image_id < MAX_IMAGE_ID;)
+          {
+             sprintf(path, pathfmt, ++td->image_id);
+             efl_file_set(event->obj, path, NULL);
+          }
+        return EO_CALLBACK_CONTINUE;
+     }
+
+   td->success = 1;
+   ecore_main_loop_quit();
+
+   return EO_CALLBACK_CONTINUE;
+}
+
+static Eina_Bool
+_timeout_cb(void *data)
+{
+   Test_Data *td = data;
+
+   td->success = 0;
+   ecore_main_loop_quit();
+
+   return ECORE_CALLBACK_CANCEL;
+}
+
+START_TEST (elm_image_async_path)
+{
+   Evas_Object *win, *image;
+   Eina_Bool one, two, ok;
+   Test_Data td;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "image", ELM_WIN_BASIC);
+
+   td.success = 0;
+   td.image_id = 0;
+
+   image = elm_image_add(win);
+   one = efl_file_async_get(image);
+   efl_file_async_set(image, 1);
+   eo_event_callback_add(image, EFL_FILE_EVENT_ASYNC_ERROR, _async_error_cb, &td);
+   eo_event_callback_add(image, EFL_FILE_EVENT_ASYNC_OPENED, _async_opened_cb, &td);
+   ok = efl_file_set(image, invalid, NULL);
+   two = efl_file_async_get(image);
+   ck_assert(!one && two);
+   ck_assert(ok);
+
+   ecore_timer_add(10.0, _timeout_cb, &td);
+
+   elm_run();
+   ck_assert(td.success);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_image_async_mmap)
+{
+   Evas_Object *win, *image;
+   Eina_Bool ok;
+   Test_Data td;
+   Eina_File *f;
+   char path[PATH_MAX];
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "image", ELM_WIN_BASIC);
+
+   td.success = 0;
+   td.image_id = 1;
+
+   sprintf(path, pathfmt, td.image_id);
+   f = eina_file_open(path, 0);
+   ck_assert(f);
+
+   image = elm_image_add(win);
+   efl_file_async_set(image, 1);
+   eo_event_callback_add(image, EFL_FILE_EVENT_ASYNC_ERROR, _async_error_cb, &td);
+   eo_event_callback_add(image, EFL_FILE_EVENT_ASYNC_OPENED, _async_opened_cb, &td);
+   ok = efl_file_mmap_set(image, f, NULL);
+   ck_assert(ok);
+
+   ecore_timer_add(10.0, _timeout_cb, &td);
+
+   elm_run();
+   ck_assert(td.success);
+
+   eina_file_close(f);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_image(TCase *tc)
+{
+    tcase_add_test(tc, elm_atspi_role_get);
+    tcase_add_test(tc, elm_image_async_path);
+    tcase_add_test(tc, elm_image_async_mmap);
+}
diff --git a/src/tests/elementary/elm_test_index.c b/src/tests/elementary/elm_test_index.c
new file mode 100644
index 0000000000..1a34933cc1
--- /dev/null
+++ b/src/tests/elementary/elm_test_index.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *idx;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "index", ELM_WIN_BASIC);
+
+   idx = elm_index_add(win);
+   role = elm_interface_atspi_accessible_role_get(idx);
+
+   ck_assert(role == ELM_ATSPI_ROLE_SCROLL_BAR);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_index(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_init.c b/src/tests/elementary/elm_test_init.c
new file mode 100644
index 0000000000..3e3210c9f7
--- /dev/null
+++ b/src/tests/elementary/elm_test_init.c
@@ -0,0 +1,18 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Elementary.h>
+#include "elm_suite.h"
+
+START_TEST (elm_main)
+{
+    ck_assert(elm_init(1, NULL) == 1);
+    ck_assert(elm_shutdown() == 0);
+}
+END_TEST
+
+void elm_test_init(TCase *tc)
+{
+   tcase_add_test(tc, elm_main);
+}
diff --git a/src/tests/elementary/elm_test_inwin.c b/src/tests/elementary/elm_test_inwin.c
new file mode 100644
index 0000000000..942945dff5
--- /dev/null
+++ b/src/tests/elementary/elm_test_inwin.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *inwin;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "inwin", ELM_WIN_BASIC);
+
+   inwin = elm_win_inwin_add(win);
+   role = elm_interface_atspi_accessible_role_get(inwin);
+
+   ck_assert(role == ELM_ATSPI_ROLE_GLASS_PANE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_inwin(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_label.c b/src/tests/elementary/elm_test_label.c
new file mode 100644
index 0000000000..a81fdf4418
--- /dev/null
+++ b/src/tests/elementary/elm_test_label.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *label;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "label", ELM_WIN_BASIC);
+
+   label = elm_label_add(win);
+   role = elm_interface_atspi_accessible_role_get(label);
+
+   ck_assert(role == ELM_ATSPI_ROLE_LABEL);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_label(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_layout.c b/src/tests/elementary/elm_test_layout.c
new file mode 100644
index 0000000000..5ccfb50f82
--- /dev/null
+++ b/src/tests/elementary/elm_test_layout.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *layout;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "layout", ELM_WIN_BASIC);
+
+   layout = elm_layout_add(win);
+   role = elm_interface_atspi_accessible_role_get(layout);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FILLER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_layout(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_list.c b/src/tests/elementary/elm_test_list.c
new file mode 100644
index 0000000000..3afd06249c
--- /dev/null
+++ b/src/tests/elementary/elm_test_list.c
@@ -0,0 +1,246 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_SELECTION_PROTECTED
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+#if 0
+// Skip following tests until Elm_Widget_Item will migrate to Eo infrastructure
+// and following features can be implemented
+
+START_TEST (elm_list_atspi_selection_selected_children_count_get)
+{
+ Evas_Object *win, *list;
+ Elm_Object_Item *item;
+ int val;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+ item = elm_list_item_append(list, "First Element", NULL, NULL, NULL, NULL);
+
+ val = elm_interface_atspi_selection_selected_children_count_get(list);
+ ck_assert(val == 0);
+
+ elm_list_item_selected_set(item, EINA_TRUE);
+ val = elm_interface_atspi_selection_selected_children_count_get(list);
+ ck_assert(val == 1);
+
+ elm_list_item_selected_set(item, EINA_FALSE);
+ val = elm_interface_atspi_selection_selected_children_count_get(list);
+ ck_assert(val == 0);
+
+ elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_list_atspi_selection_child_select)
+{
+ Evas_Object *win, *list;
+ Elm_Object_Item *item;
+ Eina_Bool val;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+ item = elm_list_item_append(list, "First Element", NULL, NULL, NULL, NULL);
+
+ val = elm_interface_atspi_selection_child_select(list, 0);
+ ck_assert(val == EINA_TRUE);
+ ck_assert(EINA_TRUE == elm_list_item_selected_get(item));
+
+ elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_list_atspi_selection_selected_child_deselect)
+{
+ Evas_Object *win, *list;
+ Elm_Object_Item *item;
+ Eina_Bool val;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+ elm_list_multi_select_set(list, EINA_TRUE);
+ elm_list_item_append(list, "First Element", NULL, NULL, NULL, NULL);
+ item = elm_list_item_append(list, "Second Element", NULL, NULL, NULL, NULL);
+
+ elm_list_item_selected_set(item, EINA_TRUE);
+ val = elm_interface_atspi_selection_selected_child_deselect(list, 0);
+ ck_assert(val == EINA_TRUE);
+ ck_assert(EINA_FALSE == elm_list_item_selected_get(item));
+
+ elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_list_atspi_selection_is_child_selected)
+{
+ Evas_Object *win, *list;
+ Elm_Object_Item *item;
+ Eina_Bool val;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+ item = elm_list_item_append(list, "First Element", NULL, NULL, NULL, NULL);
+
+ val = elm_interface_atspi_selection_is_child_selected(list, 0);
+ ck_assert(val == EINA_FALSE);
+
+ elm_list_item_selected_set(item, EINA_TRUE);
+ val = elm_interface_atspi_selection_is_child_selected(list, 0);
+ ck_assert(val == EINA_TRUE);
+
+ elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_list_atspi_selection_all_children_select)
+{
+ Evas_Object *win, *list;
+ Elm_Object_Item *item1, *item2;
+ Eina_Bool val;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+
+ item1 = elm_list_item_append(list, "First Element", NULL, NULL, NULL, NULL);
+ item2 = elm_list_item_append(list, "Second Element", NULL, NULL, NULL, NULL);
+
+ val = elm_interface_atspi_selection_all_children_select(list);
+ ck_assert(val == EINA_FALSE);
+
+ elm_list_multi_select_set(list, EINA_TRUE);
+ val = elm_interface_atspi_selection_all_children_select(list);
+ ck_assert(val == EINA_TRUE);
+ ck_assert(EINA_TRUE == elm_list_item_selected_get(item1));
+ ck_assert(EINA_TRUE == elm_list_item_selected_get(item2));
+
+ elm_shutdown();
+}
+END_TEST
+
+
+START_TEST (elm_list_atspi_selection_clear)
+{
+ Evas_Object *win, *list;
+ Elm_Object_Item *item1, *item2;
+ Eina_Bool val;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+ elm_list_multi_select_set(list, EINA_TRUE);
+ item1 = elm_list_item_append(list, "First Element", NULL, NULL, NULL, NULL);
+ item2 = elm_list_item_append(list, "Second Element", NULL, NULL, NULL, NULL);
+ elm_list_item_selected_set(item1, EINA_TRUE);
+ elm_list_item_selected_set(item2, EINA_TRUE);
+
+
+ val = elm_interface_atspi_selection_clear(list);
+ ck_assert(val == EINA_TRUE);
+ ck_assert(EINA_FALSE == elm_list_item_selected_get(item1));
+ ck_assert(EINA_FALSE == elm_list_item_selected_get(item2));
+
+ elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_list_atspi_selection_child_deselect)
+{
+ Evas_Object *win, *list;
+ Elm_Object_Item *item;
+ Eina_Bool val;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+ elm_list_multi_select_set(list, EINA_TRUE);
+ elm_list_item_append(list, "First Element", NULL, NULL, NULL, NULL);
+ item = elm_list_item_append(list, "Second Element", NULL, NULL, NULL, NULL);
+
+ elm_list_item_selected_set(item, EINA_TRUE);
+ val = elm_interface_atspi_selection_selected_child_deselect(list, 1);
+ ck_assert(val == EINA_TRUE);
+ ck_assert(EINA_FALSE == elm_list_item_selected_get(item));
+
+ elm_shutdown();
+}
+END_TEST
+
+#endif
+
+START_TEST (elm_atspi_role_get)
+{
+ Evas_Object *win, *list;
+ Elm_Atspi_Role role;
+
+ elm_init(1, NULL);
+ win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+ list = elm_list_add(win);
+ role = elm_interface_atspi_accessible_role_get(list);
+
+ ck_assert(role == ELM_ATSPI_ROLE_LIST);
+
+ elm_shutdown();
+}
+END_TEST
+
+
+/**
+ * Validate if genlist implementation properly reset parent to Elm_Genlist_Item
+ * from Elm_Genlist
+ */
+START_TEST(elm_atspi_children_parent)
+{
+   Elm_Interface_Atspi_Accessible *parent;
+
+   elm_init(1, NULL);
+   Evas_Object *win = elm_win_add(NULL, "list", ELM_WIN_BASIC);
+
+   Evas_Object *icon = elm_icon_add(win);
+   Evas_Object *end = elm_icon_add(win);
+
+   Evas_Object *list = elm_list_add(win);
+   elm_list_item_append(list, "First Element", icon, end, NULL, NULL);
+
+   evas_object_show(list);
+
+   parent = elm_interface_atspi_accessible_parent_get(icon);
+   ck_assert(list == parent);
+
+   parent = elm_interface_atspi_accessible_parent_get(end);
+   ck_assert(list == parent);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_list(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+#if 0
+ tcase_add_test(tc, elm_list_atspi_selection_selected_children_count_get);
+ tcase_add_test(tc, elm_list_atspi_selection_child_select);
+ tcase_add_test(tc, elm_list_atspi_selection_selected_child_deselect);
+ tcase_add_test(tc, elm_list_atspi_selection_is_child_selected);
+ tcase_add_test(tc, elm_list_atspi_selection_all_children_select);
+ tcase_add_test(tc, elm_list_atspi_selection_clear);
+ tcase_add_test(tc, elm_list_atspi_selection_child_deselect);
+#endif
+ tcase_add_test(tc, elm_atspi_children_parent);
+}
diff --git a/src/tests/elementary/elm_test_map.c b/src/tests/elementary/elm_test_map.c
new file mode 100644
index 0000000000..efaaa8f7f5
--- /dev/null
+++ b/src/tests/elementary/elm_test_map.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *map;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "map", ELM_WIN_BASIC);
+
+   map = elm_map_add(win);
+   role = elm_interface_atspi_accessible_role_get(map);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE_MAP);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_map(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_mapbuf.c b/src/tests/elementary/elm_test_mapbuf.c
new file mode 100644
index 0000000000..570d37f4cd
--- /dev/null
+++ b/src/tests/elementary/elm_test_mapbuf.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *mapbuf;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "mapbuf", ELM_WIN_BASIC);
+
+   mapbuf = elm_mapbuf_add(win);
+   role = elm_interface_atspi_accessible_role_get(mapbuf);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE_MAP);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_mapbuf(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_menu.c b/src/tests/elementary/elm_test_menu.c
new file mode 100644
index 0000000000..015bc89855
--- /dev/null
+++ b/src/tests/elementary/elm_test_menu.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *menu;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "menu", ELM_WIN_BASIC);
+
+   menu = elm_menu_add(win);
+   role = elm_interface_atspi_accessible_role_get(menu);
+
+   ck_assert(role == ELM_ATSPI_ROLE_MENU);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_menu(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_multibuttonentry.c b/src/tests/elementary/elm_test_multibuttonentry.c
new file mode 100644
index 0000000000..9a8a34a26f
--- /dev/null
+++ b/src/tests/elementary/elm_test_multibuttonentry.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *multibuttonentry;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "multibuttonentry", ELM_WIN_BASIC);
+
+   multibuttonentry = elm_multibuttonentry_add(win);
+   role = elm_interface_atspi_accessible_role_get(multibuttonentry);
+
+   ck_assert(role == ELM_ATSPI_ROLE_ENTRY);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_multibuttonentry(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_naviframe.c b/src/tests/elementary/elm_test_naviframe.c
new file mode 100644
index 0000000000..a34ce3e6ed
--- /dev/null
+++ b/src/tests/elementary/elm_test_naviframe.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *naviframe;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "naviframe", ELM_WIN_BASIC);
+
+   naviframe = elm_naviframe_add(win);
+   role = elm_interface_atspi_accessible_role_get(naviframe);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PAGE_TAB_LIST);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_naviframe(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_notify.c b/src/tests/elementary/elm_test_notify.c
new file mode 100644
index 0000000000..9fe99cf01f
--- /dev/null
+++ b/src/tests/elementary/elm_test_notify.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *notify;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "notify", ELM_WIN_BASIC);
+
+   notify = elm_notify_add(win);
+   role = elm_interface_atspi_accessible_role_get(notify);
+
+   ck_assert(role == ELM_ATSPI_ROLE_NOTIFICATION);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_notify(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_panel.c b/src/tests/elementary/elm_test_panel.c
new file mode 100644
index 0000000000..e98792ee6f
--- /dev/null
+++ b/src/tests/elementary/elm_test_panel.c
@@ -0,0 +1,31 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *panel;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "panel", ELM_WIN_BASIC);
+
+   panel = elm_panel_add(win);
+   role = elm_interface_atspi_accessible_role_get(panel);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PANEL);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_panel(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
+
diff --git a/src/tests/elementary/elm_test_panes.c b/src/tests/elementary/elm_test_panes.c
new file mode 100644
index 0000000000..fea0a02e27
--- /dev/null
+++ b/src/tests/elementary/elm_test_panes.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *panes;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "panes", ELM_WIN_BASIC);
+
+   panes = elm_panes_add(win);
+   role = elm_interface_atspi_accessible_role_get(panes);
+
+   ck_assert(role == ELM_ATSPI_ROLE_SPLIT_PANE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_panes(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_photo.c b/src/tests/elementary/elm_test_photo.c
new file mode 100644
index 0000000000..3d8bc5fc45
--- /dev/null
+++ b/src/tests/elementary/elm_test_photo.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *photo;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "photo", ELM_WIN_BASIC);
+
+   photo = elm_photo_add(win);
+   role = elm_interface_atspi_accessible_role_get(photo);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_photo(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_photocam.c b/src/tests/elementary/elm_test_photocam.c
new file mode 100644
index 0000000000..e8d1f78c59
--- /dev/null
+++ b/src/tests/elementary/elm_test_photocam.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *photocam;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "photocam", ELM_WIN_BASIC);
+
+   photocam = elm_photocam_add(win);
+   role = elm_interface_atspi_accessible_role_get(photocam);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_photocam(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_player.c b/src/tests/elementary/elm_test_player.c
new file mode 100644
index 0000000000..863bfba009
--- /dev/null
+++ b/src/tests/elementary/elm_test_player.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *player;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "player", ELM_WIN_BASIC);
+
+   player = elm_player_add(win);
+   role = elm_interface_atspi_accessible_role_get(player);
+
+   ck_assert(role == ELM_ATSPI_ROLE_ANIMATION);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_player(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_plug.c b/src/tests/elementary/elm_test_plug.c
new file mode 100644
index 0000000000..8139ae538a
--- /dev/null
+++ b/src/tests/elementary/elm_test_plug.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *plug;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "plug", ELM_WIN_BASIC);
+
+   plug = elm_plug_add(win);
+   role = elm_interface_atspi_accessible_role_get(plug);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_plug(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_popup.c b/src/tests/elementary/elm_test_popup.c
new file mode 100644
index 0000000000..b284475441
--- /dev/null
+++ b/src/tests/elementary/elm_test_popup.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *popup;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "popup", ELM_WIN_BASIC);
+
+   popup = elm_popup_add(win);
+   role = elm_interface_atspi_accessible_role_get(popup);
+
+   ck_assert(role == ELM_ATSPI_ROLE_NOTIFICATION);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_popup(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_prefs.c b/src/tests/elementary/elm_test_prefs.c
new file mode 100644
index 0000000000..b27d5705e1
--- /dev/null
+++ b/src/tests/elementary/elm_test_prefs.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *prefs;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "prefs", ELM_WIN_BASIC);
+
+   prefs = elm_prefs_add(win);
+   role = elm_interface_atspi_accessible_role_get(prefs);
+
+   ck_assert(role == ELM_ATSPI_ROLE_REDUNDANT_OBJECT);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_prefs(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_progressbar.c b/src/tests/elementary/elm_test_progressbar.c
new file mode 100644
index 0000000000..53319d7fff
--- /dev/null
+++ b/src/tests/elementary/elm_test_progressbar.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *progressbar;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "progressbar", ELM_WIN_BASIC);
+
+   progressbar = elm_progressbar_add(win);
+   role = elm_interface_atspi_accessible_role_get(progressbar);
+
+   ck_assert(role == ELM_ATSPI_ROLE_PROGRESS_BAR);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_progressbar(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_radio.c b/src/tests/elementary/elm_test_radio.c
new file mode 100644
index 0000000000..874dbe7d4b
--- /dev/null
+++ b/src/tests/elementary/elm_test_radio.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *radio;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "radio", ELM_WIN_BASIC);
+
+   radio = elm_radio_add(win);
+   role = elm_interface_atspi_accessible_role_get(radio);
+
+   ck_assert(role == ELM_ATSPI_ROLE_RADIO_BUTTON);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_radio(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_scroller.c b/src/tests/elementary/elm_test_scroller.c
new file mode 100644
index 0000000000..537710f4d5
--- /dev/null
+++ b/src/tests/elementary/elm_test_scroller.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *scroller;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "scroller", ELM_WIN_BASIC);
+
+   scroller = elm_scroller_add(win);
+   role = elm_interface_atspi_accessible_role_get(scroller);
+
+   ck_assert(role == ELM_ATSPI_ROLE_SCROLL_PANE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_scroller(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_segmentcontrol.c b/src/tests/elementary/elm_test_segmentcontrol.c
new file mode 100644
index 0000000000..31812e6fef
--- /dev/null
+++ b/src/tests/elementary/elm_test_segmentcontrol.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *segmentcontrol;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "segmentcontrol", ELM_WIN_BASIC);
+
+   segmentcontrol = elm_segment_control_add(win);
+   role = elm_interface_atspi_accessible_role_get(segmentcontrol);
+
+   ck_assert(role == ELM_ATSPI_ROLE_LIST);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_segmentcontrol(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_separator.c b/src/tests/elementary/elm_test_separator.c
new file mode 100644
index 0000000000..a786cd367b
--- /dev/null
+++ b/src/tests/elementary/elm_test_separator.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *separator;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "icon", ELM_WIN_BASIC);
+
+   separator = elm_separator_add(win);
+   role = elm_interface_atspi_accessible_role_get(separator);
+
+   ck_assert(role == ELM_ATSPI_ROLE_SEPARATOR);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_separator(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_slider.c b/src/tests/elementary/elm_test_slider.c
new file mode 100644
index 0000000000..59e359de53
--- /dev/null
+++ b/src/tests/elementary/elm_test_slider.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *slider;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "slider", ELM_WIN_BASIC);
+
+   slider = elm_slider_add(win);
+   role = elm_interface_atspi_accessible_role_get(slider);
+
+   ck_assert(role == ELM_ATSPI_ROLE_SLIDER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_slider(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_slideshow.c b/src/tests/elementary/elm_test_slideshow.c
new file mode 100644
index 0000000000..8edacc5e9f
--- /dev/null
+++ b/src/tests/elementary/elm_test_slideshow.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *slideshow;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "slideshow", ELM_WIN_BASIC);
+
+   slideshow = elm_slideshow_add(win);
+   role = elm_interface_atspi_accessible_role_get(slideshow);
+
+   ck_assert(role == ELM_ATSPI_ROLE_DOCUMENT_PRESENTATION);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_slideshow(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_spinner.c b/src/tests/elementary/elm_test_spinner.c
new file mode 100644
index 0000000000..bc77c97380
--- /dev/null
+++ b/src/tests/elementary/elm_test_spinner.c
@@ -0,0 +1,31 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *spinner;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "spinner", ELM_WIN_BASIC);
+
+   spinner = elm_spinner_add(win);
+   role = elm_interface_atspi_accessible_role_get(spinner);
+
+   ck_assert(role == ELM_ATSPI_ROLE_SPIN_BUTTON);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_spinner(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
+
diff --git a/src/tests/elementary/elm_test_table.c b/src/tests/elementary/elm_test_table.c
new file mode 100644
index 0000000000..bb7edc5b19
--- /dev/null
+++ b/src/tests/elementary/elm_test_table.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *table;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "table", ELM_WIN_BASIC);
+
+   table = elm_table_add(win);
+   role = elm_interface_atspi_accessible_role_get(table);
+
+   ck_assert(role == ELM_ATSPI_ROLE_FILLER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_table(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_thumb.c b/src/tests/elementary/elm_test_thumb.c
new file mode 100644
index 0000000000..3a06b0cd73
--- /dev/null
+++ b/src/tests/elementary/elm_test_thumb.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *thumb;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "thumb", ELM_WIN_BASIC);
+
+   thumb = elm_thumb_add(win);
+   role = elm_interface_atspi_accessible_role_get(thumb);
+
+   ck_assert(role == ELM_ATSPI_ROLE_IMAGE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_thumb(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_toolbar.c b/src/tests/elementary/elm_test_toolbar.c
new file mode 100644
index 0000000000..d50f50b455
--- /dev/null
+++ b/src/tests/elementary/elm_test_toolbar.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *toolbar;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "toolbar", ELM_WIN_BASIC);
+
+   toolbar = elm_toolbar_add(win);
+   role = elm_interface_atspi_accessible_role_get(toolbar);
+
+   ck_assert(role == ELM_ATSPI_ROLE_TOOL_BAR);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_toolbar(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_video.c b/src/tests/elementary/elm_test_video.c
new file mode 100644
index 0000000000..f3b7fea2d2
--- /dev/null
+++ b/src/tests/elementary/elm_test_video.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *video;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "video", ELM_WIN_BASIC);
+
+   video = elm_video_add(win);
+   role = elm_interface_atspi_accessible_role_get(video);
+
+   ck_assert(role == ELM_ATSPI_ROLE_ANIMATION);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_video(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_web.c b/src/tests/elementary/elm_test_web.c
new file mode 100644
index 0000000000..5efa8f0671
--- /dev/null
+++ b/src/tests/elementary/elm_test_web.c
@@ -0,0 +1,30 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#include <Elementary.h>
+#include "elm_suite.h"
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win, *web;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "web", ELM_WIN_BASIC);
+
+   web = elm_web_add(win);
+   role = elm_interface_atspi_accessible_role_get(web);
+
+   ck_assert(role == ELM_ATSPI_ROLE_HTML_CONTAINER);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_web(TCase *tc)
+{
+ tcase_add_test(tc, elm_atspi_role_get);
+}
diff --git a/src/tests/elementary/elm_test_win.c b/src/tests/elementary/elm_test_win.c
new file mode 100644
index 0000000000..b10d5610aa
--- /dev/null
+++ b/src/tests/elementary/elm_test_win.c
@@ -0,0 +1,205 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#define ELM_INTERFACE_ATSPI_ACCESSIBLE_PROTECTED
+#define ELM_INTERFACE_ATSPI_COMPONENT_PROTECTED
+#include <Elementary.h>
+#include <Ecore_X.h>
+#include "elm_suite.h"
+
+static const double _timeout1 = 0.01;
+static const double _timeout2 = 0.02;
+static const double _timeout_fail = 2.0;
+
+static void
+_do_delete_request(Eo *win)
+{
+#ifdef HAVE_ELEMENTARY_X
+   Ecore_X_Window xwin;
+   xwin = elm_obj_win_xwindow_get(win);
+   ecore_x_window_delete_request_send(xwin);
+#endif
+
+   (void) win;
+}
+
+
+static Eina_Bool
+_timer_delete_request_cb(void *data)
+{
+   Eo *win = (Eo*) data;
+   _do_delete_request(win);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_timer_hide_window_cb(void *data)
+{
+   Eo *win = (Eo*) data;
+   efl_gfx_visible_set(win, EINA_FALSE);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_timer_exit_cb(void *data EINA_UNUSED)
+{
+   elm_exit();
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_timer_fail_flag_cb(void *data)
+{
+   Eina_Bool *fail_flag = (Eina_Bool*) data;
+   *fail_flag = EINA_TRUE;
+   elm_exit();
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+
+START_TEST (elm_atspi_role_get)
+{
+   Evas_Object *win;
+   Elm_Atspi_Role role;
+
+   elm_init(1, NULL);
+   win = elm_win_add(NULL, "win", ELM_WIN_BASIC);
+
+   role = elm_interface_atspi_accessible_role_get(win);
+
+   ck_assert(role == ELM_ATSPI_ROLE_WINDOW);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_component_position)
+{
+   Eina_Bool ret;
+   int x, y;
+
+   elm_init(0, NULL);
+
+   Eo *win = elm_win_add(NULL, "win", ELM_WIN_BASIC);
+
+   ret = elm_interface_atspi_component_position_set(win, EINA_TRUE, 45, 45);
+   ck_assert(ret == EINA_TRUE);
+
+   Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(win));
+   ck_assert(ee != NULL);
+   ecore_evas_geometry_get(ee, &x, &y, NULL, NULL);
+
+   ck_assert((x == 45) && (y == 45));
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_atspi_component_size)
+{
+   Eina_Bool ret;
+   int w, h;
+
+   elm_init(0, NULL);
+
+   Eo *win = elm_win_add(NULL, "win", ELM_WIN_BASIC);
+   evas_object_resize(win, 50, 50);
+
+   ret = elm_interface_atspi_component_size_set(win, 100, 100);
+   ck_assert(ret == EINA_TRUE);
+
+   evas_object_geometry_get(win, NULL, NULL, &w, &h);
+   ck_assert((w == 100) && (h == 100));
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_win_autohide)
+{
+   elm_init(0, NULL);
+
+   Eo *win = elm_win_add(NULL, "win", ELM_WIN_BASIC);
+   elm_obj_win_autohide_set(win, EINA_TRUE);
+   efl_gfx_visible_set(win, EINA_TRUE);
+
+   Eina_Bool fail_flag = EINA_FALSE;
+   ecore_timer_add(_timeout1, _timer_delete_request_cb, win);
+   ecore_timer_add(_timeout2, _timer_exit_cb, &fail_flag);
+
+   elm_run();
+
+   Eina_Bool visible;
+   visible = efl_gfx_visible_get(win);
+
+   ck_assert(visible == EINA_FALSE);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_win_policy_quit_last_window_hidden)
+{
+   elm_init(0, NULL);
+
+   elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN);
+
+   Eo *win = elm_win_add(NULL, "win", ELM_WIN_BASIC);
+   efl_gfx_visible_set(win, EINA_TRUE);
+
+   Eina_Bool fail_flag = EINA_FALSE;
+   ecore_timer_add(_timeout1, _timer_hide_window_cb, win);
+   ecore_timer_add(_timeout_fail, _timer_fail_flag_cb, &fail_flag);
+
+   elm_run();
+
+   Eina_Bool visible;
+   visible = efl_gfx_visible_get(win);
+
+   ck_assert(fail_flag == EINA_FALSE);
+   ck_assert(eo_ref_get(win) >= 1);
+   ck_assert(visible == EINA_FALSE);
+
+   elm_shutdown();
+}
+END_TEST
+
+START_TEST (elm_win_autohide_and_policy_quit_last_window_hidden)
+{
+   elm_init(0, NULL);
+
+   elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN);
+
+   Eo *win = elm_win_add(NULL, "win", ELM_WIN_BASIC);
+   elm_obj_win_autohide_set(win, EINA_TRUE);
+   efl_gfx_visible_set(win, EINA_TRUE);
+
+   Eina_Bool fail_flag = EINA_FALSE;
+   ecore_timer_add(_timeout1, _timer_delete_request_cb, win);
+   ecore_timer_add(_timeout_fail, _timer_fail_flag_cb, &fail_flag);
+
+   elm_run();
+
+   Eina_Bool visible;
+   visible = efl_gfx_visible_get(win);
+
+   ck_assert(fail_flag == EINA_FALSE);
+   ck_assert(eo_ref_get(win) >= 1);
+   ck_assert(visible == EINA_FALSE);
+
+   elm_shutdown();
+}
+END_TEST
+
+void elm_test_win(TCase *tc)
+{
+   tcase_add_test(tc, elm_atspi_role_get);
+   tcase_add_test(tc, elm_atspi_component_position);
+   tcase_add_test(tc, elm_atspi_component_size);
+   tcase_add_test(tc, elm_win_policy_quit_last_window_hidden);
+#ifdef HAVE_ELEMENTARY_X
+   tcase_add_test(tc, elm_win_autohide);
+   tcase_add_test(tc, elm_win_autohide_and_policy_quit_last_window_hidden);
+#endif
+}