New tests for last interfaces

    * Tested interfaces:
        - Document
        - Hyperlink
        - Hypertext
        - Selectoin
        - State Set
        - Table
        - Table Cell

14 files changed, 2036 insertions, 0 deletions

diff --git a/tests/dummyatk/Makefile.am b/tests/dummyatk/Makefile.am
index e8049b6..c590cce 100644
--- a/tests/dummyatk/Makefile.am
+++ b/tests/dummyatk/Makefile.am
@@ -17,14 +17,26 @@ libdummyatk_la_SOURCES = \
 			 my-atk-action.h \
 			 my-atk-component.c \
 			 my-atk-component.h \
+			 my-atk-document.c \
+			 my-atk-document.h \
 			 my-atk-editable-text.c \
 			 my-atk-editable-text.h \
+			 my-atk-hyperlink.c \
+			 my-atk-hyperlink.h \
+			 my-atk-hypertext.c \
+			 my-atk-hypertext.h \
 			 my-atk-image.c \
 			 my-atk-image.h \
 			 my-atk-text.c \
 			 my-atk-text.h \
 			 my-atk-object.c \
 			 my-atk-object.h \
+			 my-atk-table.c \
+			 my-atk-table.h \
+			 my-atk-table-cell.c \
+			 my-atk-table-cell.h \
+			 my-atk-selection.c \
+			 my-atk-selection.h \
 			 my-atk-value.c \
 			 my-atk-value.h \
 			 my-atk.h
diff --git a/tests/dummyatk/my-atk-document.c b/tests/dummyatk/my-atk-document.c
new file mode 100644
index 0000000..62b0c81
--- /dev/null
+++ b/tests/dummyatk/my-atk-document.c
@@ -0,0 +1,152 @@
+/*
+ * AT-SPI - Assistive Technology Service Provider Interface
+ * (Gnome Accessibility Project; https://wiki.gnome.org/Accessibility)
+ *
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <glib-object.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+#include "my-atk-document.h"
+
+static void atk_document_interface_init (AtkDocumentIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MyAtkDocument,
+                         my_atk_document,
+                         MY_TYPE_ATK_OBJECT,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_DOCUMENT,
+                             atk_document_interface_init));
+
+void
+my_atk_set_document (AtkDocument *obj, gint page, gint page_num)
+{
+  g_return_if_fail (MY_IS_ATK_DOCUMENT(obj));
+  MyAtkDocument *self = MY_ATK_DOCUMENT	(obj);
+
+  self->pages = page;
+  self->current_page = page_num;
+
+  AtkAttribute *attr1, *attr2;
+  attr1 = g_malloc (sizeof (AtkAttribute));
+  attr1->name = g_strdup ("atspi1");
+  attr1->value = g_strdup ("test1");
+
+  attr2 = g_malloc (sizeof (AtkAttribute));
+  attr2->name = g_strdup ("atspi2");
+  attr2->value = g_strdup ("test2");
+
+  self->attributes = g_slist_append (NULL, attr1);
+  self->attributes = g_slist_append (self->attributes, attr2);
+}
+
+static void
+my_atk_document_init (MyAtkDocument *obj)
+{
+  obj->disposed = FALSE;
+  obj->locale = NULL;
+  obj->document_type = NULL;
+  obj->pages = 0;
+  obj->current_page = 0;
+}
+
+AtkAttributeSet *
+my_atk_document_get_document_attributes (AtkDocument *document)
+{
+  MyAtkDocument *self = MY_ATK_DOCUMENT (document);
+
+  return self->attributes;
+}
+
+const gchar *
+my_atk_document_get_document_attribute_value (AtkDocument *document, const gchar *value)
+{
+  AtkAttributeSet *attr = my_atk_document_get_document_attributes (document);
+  GSList *cur_attr = (GSList *) attr;
+  AtkAttribute *at;
+
+  while (cur_attr) {
+    at = (AtkAttribute *) cur_attr->data;
+    if (!g_strcmp0 (at->name, value)) {
+      return at->value;
+    }
+    cur_attr = cur_attr->next;
+  }
+  return NULL;
+}
+
+gboolean
+my_atk_document_set_document_attribute (AtkDocument *document, const gchar *attribute_name, const gchar *attribute_value)
+{
+  return FALSE;
+}
+
+gint
+my_atk_document_get_current_page_number (AtkDocument *document)
+{
+  return 0;
+}
+
+gint
+my_atk_document_get_page_count (AtkDocument *document)
+{
+  return 0;
+}
+
+const gchar *
+my_atk_document_get_document_locale (AtkDocument *document)
+{
+
+  return g_strdup("document_locale");
+}
+
+static void
+atk_document_interface_init(AtkDocumentIface *iface)
+{
+  if(!iface) return;
+
+  iface->get_document_locale = my_atk_document_get_document_locale;
+  iface->get_document_attributes = my_atk_document_get_document_attributes;
+  iface->get_document_attribute_value = my_atk_document_get_document_attribute_value;
+  iface->set_document_attribute = my_atk_document_set_document_attribute;
+  iface->get_current_page_number = my_atk_document_get_current_page_number;
+  iface->get_page_count = my_atk_document_get_page_count;
+}
+
+static void
+my_atk_document_initialize(AtkObject *obj, gpointer data)
+{
+}
+
+static void
+my_atk_document_finalize(GObject *object)
+{
+}
+
+static void
+my_atk_document_class_init(MyAtkDocumentClass *my_class)
+{
+  AtkObjectClass *atk_class = ATK_OBJECT_CLASS(my_class);
+  GObjectClass *gobject_class = G_OBJECT_CLASS(my_class);
+
+  gobject_class->finalize = my_atk_document_finalize;
+
+  atk_class->initialize = my_atk_document_initialize;
+}
+
diff --git a/tests/dummyatk/my-atk-document.h b/tests/dummyatk/my-atk-document.h
new file mode 100644
index 0000000..47c9187
--- /dev/null
+++ b/tests/dummyatk/my-atk-document.h
@@ -0,0 +1,63 @@
+/*
+ * AT-SPI - Assistive Technology Service Provider Interface
+ * (Gnome Accessibility Project; https://wiki.gnome.org/Accessibility)
+ *
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef MY_ATK_DOCUMENT_H
+#define MY_ATK_DOCUMENT_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include <atk/atk.h>
+#include "my-atk-object.h"
+
+#define MY_TYPE_ATK_DOCUMENT                (my_atk_document_get_type ())
+#define MY_ATK_DOCUMENT(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_ATK_DOCUMENT, MyAtkDocument))
+#define MY_ATK_DOCUMENT_CLASS(vdocument)    (G_TYPE_CHECK_CLASS_CAST ((vdocument), MY_TYPE_ATK_DOCUMENT, MyAtkDocumentClass))
+#define MY_IS_ATK_DOCUMENT(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_ATK_DOCUMENT))
+#define MY_IS_ATK_DOCUMENT_CLASS(vdocument) (G_TYPE_CHECK_CLASS_TYPE ((vdocument), MY_TYPE_ATK_DOCUMENT))
+#define MY_ATK_DOCUMENT_GET_CLASS(inst)     (G_TYPE_INSTANCE_GET_CLASS ((inst), MY_TYPE_ATK_DOCUMENT, MyAtkDocumentClass))
+
+// default string values
+#define DEF_LOCALE_TEXT  "en-US"
+#define DEF_TYPE_TEXT    "default type"
+
+typedef struct _MyAtkDocument MyAtkDocument;
+typedef struct _MyAtkDocumentClass MyAtkDocumentClass;
+
+struct _MyAtkDocument {
+  MyAtkObject parent;
+  gboolean disposed;
+  gchar *locale;
+  gchar *document_type;
+  gint pages;
+  gint current_page;
+  AtkAttributeSet *attributes;
+};
+
+struct _MyAtkDocumentClass {
+  MyAtkObjectClass parent;
+};
+
+GType my_atk_document_get_type (void);
+
+void my_atk_set_document (AtkDocument *obj, gint page, gint page_num);
+
+#endif /*MY_ATK_DOCUMENT_H*/
diff --git a/tests/dummyatk/my-atk-hyperlink.c b/tests/dummyatk/my-atk-hyperlink.c
new file mode 100644
index 0000000..834369d
--- /dev/null
+++ b/tests/dummyatk/my-atk-hyperlink.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <glib.h>
+#include <string.h>
+#include <atk/atk.h>
+#include <stdio.h>
+
+#include "my-atk-object.h"
+#include "my-atk-hyperlink.h"
+#include "my-atk-text.h"
+
+typedef struct _MyAtkHyperlinkInfo MyAtkHyperlinkInfo;
+
+G_DEFINE_TYPE (MyAtkHyperlink, my_atk_hyperlink, ATK_TYPE_HYPERLINK)
+
+gint
+my_atk_set_hyperlink (AtkHyperlink *obj, const gchar *uri, gint start, gint end)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), -1);
+
+  self->uri = g_strdup (uri);
+  self->start = start;
+  self->end = end;
+  self->state = FALSE;
+  self->selected = FALSE;
+
+  return 0;
+}
+
+MyAtkHyperlink *
+new_MyAtkHyperlink (void)
+{
+  return g_object_new (MY_TYPE_ATK_HYPERLINK, NULL);
+}
+
+static gchar*
+my_atk_hyperlink_get_uri (AtkHyperlink *obj, gint i)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), NULL);
+
+  return self->uri;
+}
+
+static AtkObject *
+my_atk_hyperlink_get_object (AtkHyperlink *obj, gint i)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  MyAtkText *text;
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), NULL);
+
+  text = my_atk_text_new ();
+  my_atk_set_text (ATK_TEXT (text),
+                   self->uri,
+                   10,
+                   50,
+                   self->end - self->start,
+                   15,
+                   NULL);
+
+  return ATK_OBJECT (text);
+}
+
+static gint
+my_atk_hyperlink_get_end_index (AtkHyperlink *obj)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), -1);
+
+  return self->end;
+}
+
+static gint
+my_atk_hyperlink_get_start_index (AtkHyperlink *obj)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), -1);
+
+  return self->start;
+}
+
+static gboolean
+my_atk_hyperlink_is_valid (AtkHyperlink *obj)
+{
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), FALSE);
+
+  return TRUE;
+}
+
+static gint
+my_atk_hyperlink_get_n_anchors (AtkHyperlink *obj)
+{
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), -1);
+
+  return 1;
+}
+
+static guint
+my_atk_hyperlink_link_state (AtkHyperlink *obj)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), -1);
+
+  return self->state;
+}
+
+static gboolean
+my_atk_hyperlink_is_selected_link (AtkHyperlink *obj)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  g_return_val_if_fail (MY_IS_ATK_HYPERLINK (obj), FALSE);
+
+  return self->selected;
+}
+
+static void
+my_atk_hyperlink_link_activated (AtkHyperlink *obj)
+{
+  MyAtkHyperlink *self = MY_ATK_HYPERLINK (obj);
+  g_return_if_fail (MY_IS_ATK_HYPERLINK (obj));
+
+  self->selected = !self->selected;
+}
+
+static void
+my_atk_hyperlink_init (MyAtkHyperlink *self)
+{
+  self->uri =NULL;
+  self->start = -1;
+  self->end = -1;
+  self->state = FALSE;
+  self->selected = FALSE;
+}
+
+static void
+my_atk_hyperlink_set_property (GObject *obj,
+                               guint id,
+                               const GValue *value,
+                               GParamSpec *spec)
+{
+  switch (id) {
+  case 1:
+    break;
+  case 2:
+    break;
+  case 3:
+    break;
+  default:
+    //G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, id, pspec);
+    break;
+  }
+}
+
+static void
+my_atk_hyperlink_get_property (GObject *obj,
+                               guint id,
+                               GValue *value,
+                               GParamSpec *pspec)
+{
+}
+
+static void
+my_atk_hyperlink_class_finalize (GObject *obj)
+{
+}
+
+static void
+my_atk_hyperlink_class_init (MyAtkHyperlinkClass *my_class)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (my_class);
+  AtkHyperlinkClass *iface = ATK_HYPERLINK_CLASS (my_class);
+  const gchar *inst_tab[] = {"accessible-name", "accessible-description", "accessible-role", NULL};
+
+  gobject_class->finalize = my_atk_hyperlink_class_finalize;
+  gobject_class->set_property = my_atk_hyperlink_set_property;
+  gobject_class->get_property = my_atk_hyperlink_get_property;
+
+  gint i;
+  for (i = 0; inst_tab[i] != NULL ; i++)
+    g_object_class_install_property (gobject_class,
+                                     i+1,
+                                     g_param_spec_string (inst_tab[i],
+                                         inst_tab[i],
+                                         inst_tab[i],
+                                         NULL,
+                                         G_PARAM_READWRITE)
+                                    );
+
+  iface->get_uri = my_atk_hyperlink_get_uri;
+  iface->get_object = my_atk_hyperlink_get_object;
+  iface->get_end_index = my_atk_hyperlink_get_end_index;
+  iface->get_start_index = my_atk_hyperlink_get_start_index;
+  iface->is_valid = my_atk_hyperlink_is_valid;
+  iface->get_n_anchors = my_atk_hyperlink_get_n_anchors;
+  iface->link_state = my_atk_hyperlink_link_state;
+  iface->is_selected_link = my_atk_hyperlink_is_selected_link;
+  iface->link_activated = my_atk_hyperlink_link_activated;
+}
diff --git a/tests/dummyatk/my-atk-hyperlink.h b/tests/dummyatk/my-atk-hyperlink.h
new file mode 100644
index 0000000..566d12d
--- /dev/null
+++ b/tests/dummyatk/my-atk-hyperlink.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef MY_ATK_HYPERLINK_H_
+#define MY_ATK_HYPERLINK_H_
+
+#include <glib.h>
+#include <glib-object.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+
+#define MY_TYPE_ATK_HYPERLINK             (my_atk_hyperlink_get_type ())
+#define MY_ATK_HYPERLINK(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_ATK_HYPERLINK, MyAtkHyperlink))
+#define MY_ATK_HYPERLINK_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), MY_TYPE_ATK_HYPERLINK, MyAtkHyperlinkClass))
+#define MY_IS_ATK_HYPERLINK(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_ATK_HYPERLINK))
+#define MY_IS_ATK_HYPERLINK_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), MY_TYPE_ATK_HYPERLINK))
+#define MY_ATK_HYPERLINK_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), MY_TYPE_ATK_HYPERLINK, MyAtkHyperlinkClass))
+
+typedef struct _MyAtkHyperlink MyAtkHyperlink;
+typedef struct _MyAtkHyperlinkClass MyAtkHyperlinkClass;
+
+struct _MyAtkHyperlink {
+  MyAtkObject parent;
+  gchar *uri;
+  gint start;
+  gint end;
+  gboolean state;
+  gboolean selected;
+};
+
+struct _MyAtkHyperlinkClass {
+  MyAtkObjectClass parent;
+};
+
+GType my_atk_hyperlink_get_type (void);
+
+MyAtkHyperlink * new_MyAtkHyperlink (void);
+
+gint my_atk_set_hyperlink (AtkHyperlink *obj, const gchar *uri, gint start, gint end);
+
+#endif /* MY_ATK_HYPERLINK_H_ */
diff --git a/tests/dummyatk/my-atk-hypertext.c b/tests/dummyatk/my-atk-hypertext.c
new file mode 100644
index 0000000..80abb3f
--- /dev/null
+++ b/tests/dummyatk/my-atk-hypertext.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <glib.h>
+#include <string.h>
+#include <atk/atk.h>
+#include <stdio.h>
+
+#include "my-atk-object.h"
+#include "my-atk-hypertext.h"
+#include "my-atk-hyperlink.h"
+
+typedef struct _MyAtkHypertextInfo MyAtkHypertextInfo;
+
+static void atk_hypertext_interface_init (AtkHypertextIface *iface);
+static void GDestroyNotifyGOBJptrArray (gpointer data);
+
+G_DEFINE_TYPE_WITH_CODE (MyAtkHypertext,
+                         my_atk_hypertext,
+                         MY_TYPE_ATK_OBJECT,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_HYPERTEXT,
+                             atk_hypertext_interface_init));
+
+gint
+my_atk_set_hypertext (AtkHypertext *obj, const gchar *text)
+{
+  MyAtkHypertext *self = MY_ATK_HYPERTEXT (obj);
+  MyAtkHyperlink *link;
+  gchar *ptr;
+  const gchar *fstr= "href=";
+  gint len = strlen (fstr);
+  gint text_len = strlen (text);
+  gint index = 0;
+  gint start_offset;
+  g_return_val_if_fail (MY_IS_ATK_HYPERTEXT (obj), -1);
+
+  if (text_len < len)
+    return -1;
+
+  while (text) {
+    ptr = g_strstr_len (text + index, text_len - index, fstr);
+    index = ptr - text + len;
+    if (ptr) {
+      if (text_len < index || index < len)
+        break;
+      if (text[index] == '\'') {
+        start_offset = index + 1;
+        while (++index < text_len && text[index] != '\'');
+        if (text[index] != '\'')
+          break;
+        link = new_MyAtkHyperlink ();
+        my_atk_set_hyperlink (ATK_HYPERLINK (link),
+                              g_strndup (text + start_offset, index - start_offset),
+                              start_offset,
+                              index);
+        g_ptr_array_add (self->array, link);
+      }
+    } else
+      break;
+  }
+
+  return self->array->len > 0 ? 0 : -1;
+}
+
+static gint
+my_atk_hypertext_get_n_links (AtkHypertext *obj)
+{
+  MyAtkHypertext *self = MY_ATK_HYPERTEXT (obj);
+  g_return_val_if_fail (MY_IS_ATK_HYPERTEXT (obj), -1);
+  return self->array->len;
+
+}
+
+static AtkHyperlink *
+my_atk_hypertext_get_link (AtkHypertext *obj, gint link_index)
+{
+  MyAtkHypertext *self = MY_ATK_HYPERTEXT (obj);
+  AtkHyperlink *link = NULL;
+  g_return_val_if_fail (MY_IS_ATK_HYPERTEXT (obj), NULL);
+  if (0 <= link_index && link_index < self->array->len)
+    link = g_ptr_array_index (self->array, link_index);
+  return link;
+}
+
+static gint
+my_atk_hypertext_get_link_index (AtkHypertext *obj, gint char_index)
+{
+  MyAtkHypertext *self = MY_ATK_HYPERTEXT (obj);
+  gint i;
+  MyAtkHyperlink *link;
+  g_return_val_if_fail (MY_IS_ATK_HYPERTEXT (obj), -1);
+
+  for (i = 0; i < self->array->len; i++) {
+    link = g_ptr_array_index (self->array, i);
+    if (link->start <= char_index && char_index <= link->end)
+      return i;
+  }
+  return -1;
+}
+
+static void
+my_atk_hypertext_link_selected (AtkHypertext *obj, gint link_index)
+{
+  g_return_if_fail (MY_IS_ATK_HYPERTEXT (obj));
+}
+
+static void
+GDestroyNotifyGOBJptrArray (gpointer data)
+{
+  g_object_unref (data);
+}
+
+static void
+atk_hypertext_interface_init (AtkHypertextIface *iface)
+{
+  if (!iface) return;
+  iface->get_n_links = my_atk_hypertext_get_n_links;
+  iface->get_link = my_atk_hypertext_get_link;
+  iface->get_link_index = my_atk_hypertext_get_link_index;
+  iface->link_selected = my_atk_hypertext_link_selected;
+}
+
+static void
+my_atk_hypertext_init (MyAtkHypertext *self)
+{
+  self->array = g_ptr_array_new_full (2, GDestroyNotifyGOBJptrArray);
+}
+
+static void
+my_atk_hypertext_class_initialize (AtkObject *obj, gpointer data)
+{
+}
+
+static void
+my_atk_hypertext_class_finalize (GObject *obj)
+{
+}
+
+static void
+my_atk_hypertext_class_init(MyAtkHypertextClass *my_class)
+{
+  AtkObjectClass *atk_class = ATK_OBJECT_CLASS(my_class);
+  GObjectClass *gobject_class = G_OBJECT_CLASS(my_class);
+
+  gobject_class->finalize = my_atk_hypertext_class_finalize;
+
+  atk_class->initialize = my_atk_hypertext_class_initialize;
+}
diff --git a/tests/dummyatk/my-atk-hypertext.h b/tests/dummyatk/my-atk-hypertext.h
new file mode 100644
index 0000000..2dd7409
--- /dev/null
+++ b/tests/dummyatk/my-atk-hypertext.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef MY_ATK_HYPERTEXT_H_
+#define MY_ATK_HYPERTEXT_H_
+
+#include <glib.h>
+#include <glib-object.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+#define MY_TYPE_ATK_HYPERTEXT             (my_atk_hypertext_get_type ())
+#define MY_ATK_HYPERTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_ATK_HYPERTEXT, MyAtkHypertext))
+#define MY_ATK_HYPERTEXT_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), MY_TYPE_ATK_HYPERTEXT, MyAtkHypertextClass))
+#define MY_IS_ATK_HYPERTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_ATK_HYPERTEXT))
+#define MY_IS_ATK_HYPERTEXT_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), MY_TYPE_ATK_HYPERTEXT))
+#define MY_ATK_HYPERTEXT_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), MY_TYPE_ATK_HYPERTEXT, MyAtkHypertextClass))
+
+typedef struct _MyAtkHypertext MyAtkHypertext;
+typedef struct _MyAtkHypertextClass MyAtkHypertextClass;
+
+struct _MyAtkHypertext {
+  MyAtkObject parent;
+  GPtrArray *array;
+};
+
+struct _MyAtkHypertextClass {
+  MyAtkObjectClass parent;
+};
+
+GType my_atk_hypertext_get_type (void);
+
+gint my_atk_set_hypertext (AtkHypertext *obj, const gchar *text);
+
+#endif /* MY_ATK_HYPERTEXT_H_ */
diff --git a/tests/dummyatk/my-atk-selection.c b/tests/dummyatk/my-atk-selection.c
new file mode 100644
index 0000000..bf706cc
--- /dev/null
+++ b/tests/dummyatk/my-atk-selection.c
@@ -0,0 +1,229 @@
+/*
+ * AT-SPI - Assistive Technology Service Provider Interface
+ * (Gnome Accessibility Project; https://wiki.gnome.org/Accessibility)
+ *
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+#include "my-atk-selection.h"
+
+static void atk_selection_interface_init (AtkSelectionIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MyAtkSelection,
+                         my_atk_selection,
+                         MY_TYPE_ATK_OBJECT,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_SELECTION,
+                             atk_selection_interface_init));
+
+static void
+my_atk_selection_init (MyAtkSelection *obj)
+{
+}
+
+static gboolean
+my_atk_selection_add_selection (AtkSelection *selection, gint i)
+{
+  MyAtkSelection *self = MY_ATK_SELECTION(selection);
+  if (!self)
+    return FALSE;
+
+  AtkObject *child = atk_object_ref_accessible_child (ATK_OBJECT (selection), i);
+  AtkStateSet *ss = atk_object_ref_state_set (child);
+  atk_state_set_add_state (ss, ATK_STATE_SELECTED);
+  return atk_state_set_contains_state (ss, ATK_STATE_SELECTED);
+}
+
+static gboolean
+my_atk_selection_clear_selection (AtkSelection *selection)
+{
+  MyAtkSelection *self = MY_ATK_SELECTION(selection);
+  if (!self)
+    return FALSE;
+  AtkObject *child = NULL;
+  AtkStateSet *states = NULL;
+  int i;
+  int childs = atk_object_get_n_accessible_children (ATK_OBJECT (selection));
+
+  for (i=0; i<childs; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (selection), i);
+    states = atk_object_ref_state_set (child);
+    atk_state_set_remove_state (states, ATK_STATE_SELECTED);
+  }
+  return TRUE;
+}
+
+static AtkObject*
+my_atk_selection_ref_selection (AtkSelection *selection, gint no)
+{
+  MyAtkSelection *self = MY_ATK_SELECTION(selection);
+  if (!self)
+    return FALSE;
+  AtkObject *child = NULL;
+  AtkStateSet *states = NULL;
+  GArray *array = g_array_new (FALSE, FALSE, sizeof (AtkObject *));
+  int i;
+  int childs = atk_object_get_n_accessible_children (ATK_OBJECT (selection));
+
+  for (i=0; i<childs; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (selection), i);
+    states = atk_object_ref_state_set (child);
+    if (atk_state_set_contains_state (states, ATK_STATE_SELECTED))
+      g_array_append_val (array, child);
+  }
+
+  return g_array_index (array, AtkObject *, no);
+}
+
+static gint
+my_atk_selection_get_selection_count (AtkSelection *selection)
+{
+  MyAtkSelection *self = MY_ATK_SELECTION(selection);
+  if (!self)
+    return FALSE;
+  AtkObject *child = NULL;
+  AtkStateSet *states = NULL;
+  int i, ret=0;
+  int childs = atk_object_get_n_accessible_children (ATK_OBJECT (selection));
+
+  for (i=0; i<childs; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (selection), i);
+    states = atk_object_ref_state_set (child);
+    if (atk_state_set_contains_state (states, ATK_STATE_SELECTED))
+      ret++;
+
+  }
+  return ret;
+}
+
+static gboolean
+my_atk_selection_is_child_selected (AtkSelection *selection, gint i)
+{
+  MyAtkSelection *self = MY_ATK_SELECTION(selection);
+  if (!self)
+    return FALSE;
+  AtkObject *child = NULL;
+  AtkStateSet *states = NULL;
+  child = atk_object_ref_accessible_child (ATK_OBJECT (selection), i);
+  states = atk_object_ref_state_set (child);
+  if (atk_state_set_contains_state (states, ATK_STATE_SELECTED))
+    return TRUE;
+  return FALSE;
+}
+
+static gboolean
+my_atk_selection_remove_selection (AtkSelection *selection, gint no)
+{
+  MyAtkSelection *self = MY_ATK_SELECTION(selection);
+  AtkObject *child = NULL;
+  AtkStateSet *states = NULL;
+  GArray *array = NULL;
+  AtkObject *o = NULL;
+  int i;
+  int childs;
+  gboolean ret = FALSE;
+
+  if (!self)
+    return FALSE;
+  array = g_array_new (FALSE, FALSE, sizeof (AtkObject *));
+  childs = atk_object_get_n_accessible_children (ATK_OBJECT (selection));
+
+  for (i=0; i<childs; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (selection), i);
+    states = atk_object_ref_state_set (child);
+    if (atk_state_set_contains_state (states, ATK_STATE_SELECTED))
+      g_array_append_val (array, child);
+  }
+  g_object_unref (states);
+
+  o = g_array_index (array, AtkObject *, no);
+  states = atk_object_ref_state_set (o);
+  atk_state_set_remove_state (states, ATK_STATE_SELECTED);
+
+  ret = !atk_state_set_contains_state (states, ATK_STATE_SELECTED);
+  g_object_unref (states);
+  g_object_unref (o);
+  g_object_unref (self);
+  g_array_free (array, TRUE);
+
+  return ret;
+}
+
+static gboolean
+my_atk_selection_select_all_selection (AtkSelection *selection)
+{
+  MyAtkSelection *self = MY_ATK_SELECTION(selection);
+  AtkObject *child = NULL;
+  AtkStateSet *states = NULL;
+  int i;
+  int childs;
+
+  if (!self)
+    return FALSE;
+  childs = atk_object_get_n_accessible_children (ATK_OBJECT (selection));
+
+  for (i=0; i<childs; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (selection), i);
+    states = atk_object_ref_state_set (child);
+    atk_state_set_add_state (states, ATK_STATE_SELECTED);
+    g_object_unref (states);
+    g_object_unref (child);
+  }
+
+  g_object_unref (self);
+  return TRUE;
+}
+
+static void
+atk_selection_interface_init (AtkSelectionIface *iface)
+{
+  if(!iface) return;
+
+  iface->add_selection = my_atk_selection_add_selection;
+  iface->clear_selection = my_atk_selection_clear_selection;
+  iface->ref_selection = my_atk_selection_ref_selection;
+  iface->get_selection_count = my_atk_selection_get_selection_count;
+  iface->is_child_selected = my_atk_selection_is_child_selected;
+  iface->remove_selection = my_atk_selection_remove_selection;
+  iface->select_all_selection = my_atk_selection_select_all_selection;
+}
+
+static void
+my_atk_selection_initialize (AtkObject *obj, gpointer data)
+{
+}
+
+static void
+my_atk_selection_finalize (GObject *obj)
+{
+}
+
+static void
+my_atk_selection_class_init (MyAtkSelectionClass *my_class)
+{
+  AtkObjectClass *atk_class = ATK_OBJECT_CLASS(my_class);
+  GObjectClass *gobject_class = G_OBJECT_CLASS(my_class);
+
+  gobject_class->finalize = my_atk_selection_finalize;
+
+  atk_class->initialize = my_atk_selection_initialize;
+}
diff --git a/tests/dummyatk/my-atk-selection.h b/tests/dummyatk/my-atk-selection.h
new file mode 100644
index 0000000..be932e0
--- /dev/null
+++ b/tests/dummyatk/my-atk-selection.h
@@ -0,0 +1,61 @@
+/*
+ * AT-SPI - Assistive Technology Service Provider Interface
+ * (Gnome Accessibility Project; https://wiki.gnome.org/Accessibility)
+ *
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef MY_ATK_SELECTION_H
+#define MY_ATK_SELECTION_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+
+#define MY_TYPE_ATK_SELECTION             (my_atk_selection_get_type ())
+#define MY_ATK_SELECTION(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_ATK_SELECTION, MyAtkSelection))
+#define MY_ATK_SELECTION_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), MY_TYPE_ATK_SELECTION, MyAtkSelectionClass))
+#define MY_IS_ATK_SELECTION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_ATK_SELECTION))
+#define MY_IS_ATK_SELECTION_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), MY_TYPE_ATK_SELECTION))
+#define MY_ATK_SELECTION_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), MY_TYPE_ATK_SELECTION, MyAtkSelectionClass))
+
+/* Number of child objects for the MyAtkSelection instance */
+#define TEST_SELECTION_NCHILDREN 10
+
+typedef struct _MyAtkSelection MyAtkSelection;
+typedef struct _MyAtkSelectionClass MyAtkSelectionClass;
+
+struct _MyAtkSelection {
+  MyAtkObject parent;
+//    gboolean disposed;
+  //  gboolean multisel_supported;
+  //  MyAtkObject* child[TEST_SELECTION_NCHILDREN];
+  // gboolean is_selected[TEST_SELECTION_NCHILDREN];
+};
+
+struct _MyAtkSelectionClass {
+  MyAtkObjectClass parent;
+};
+
+GType my_atk_selection_get_type (void);
+
+guint my_atk_selection_set (MyAtkSelection *selection);
+#endif /*MY_ATK_SELECTION_H*/
+
diff --git a/tests/dummyatk/my-atk-table-cell.c b/tests/dummyatk/my-atk-table-cell.c
new file mode 100644
index 0000000..2d1c568
--- /dev/null
+++ b/tests/dummyatk/my-atk-table-cell.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <glib.h>
+#include <string.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+#include "my-atk-table.h"
+#include "my-atk-table-cell.h"
+
+typedef struct _MyAtkTableCellInfo MyAtkTableCellInfo;
+
+static void atk_tablecell_interface_init (AtkTableCellIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MyAtkTableCell,
+                         my_atk_tablecell,
+                         MY_TYPE_ATK_OBJECT,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_TABLE_CELL,
+                             atk_tablecell_interface_init));
+
+gboolean
+my_atk_set_table_cell (AtkTableCell *cell, gint x, gint y, gint row_span, gint column_span)
+{
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (cell), FALSE);
+  MyAtkTableCell *self = MY_ATK_TABLE_CELL (cell);
+
+  self->x = x;
+  self->y = y;
+  self->row_span = row_span;
+  self->column_span = column_span;
+
+  /* Default value for span is 1, so that condition is needed */
+  if (row_span == 0)
+    self->row_span = 1;
+  if (column_span == 0)
+    self->column_span = 1;
+
+  return TRUE;
+
+}
+gboolean
+my_atk_set_tablecell (MyAtkTableCell *self, gpointer value, const gchar *row_desc, MyAtkObject *parent_table, gboolean selected, gint *xy)
+{
+  self->value = value;
+  self->row_desc = g_strdup (row_desc);
+  self->parent_table = parent_table;
+  self->selected = selected;
+
+  memcpy (self->xy, xy, sizeof (self->xy));
+  return TRUE;
+}
+
+static gint
+my_atk_tablecell_get_column_span (AtkTableCell *obj)
+{
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (obj), -1);
+  MyAtkTableCell *self = MY_ATK_TABLE_CELL (obj);
+  return self->column_span;
+}
+
+static gboolean
+my_atk_tablecell_get_row_column_span (AtkTableCell *obj, gint *row, gint *col, gint *row_span, gint *col_span)
+{
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (obj), FALSE);
+  MyAtkTableCell *self = MY_ATK_TABLE_CELL (obj);
+  *col = self->x;
+  *row = self->y;
+  *row_span = self->row_span;
+  *col_span = self->column_span;
+  return TRUE;
+}
+
+static GPtrArray *
+my_atk_tablecell_get_column_header_cells (AtkTableCell *obj)
+{
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (obj), FALSE);
+  MyAtkTable *tab = MY_ATK_TABLE (atk_object_get_parent (ATK_OBJECT (obj)));
+
+  gint i, all_child;
+  all_child = MY_ATK_OBJECT (tab)->children->len;
+  AtkObject *child = NULL;
+  GPtrArray *ret = g_ptr_array_new_full (atk_table_get_n_columns ATK_TABLE (tab), g_object_unref);
+
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (tab), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER) {
+      g_ptr_array_add (ret, child);
+    }
+  }
+
+  return ret;
+}
+
+static AtkObject *
+my_atk_tablecell_get_table (AtkTableCell *obj)
+{
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (obj), NULL);
+
+  return atk_object_get_parent (ATK_OBJECT (obj));
+}
+
+static gint
+my_atk_tablecell_get_row_span (AtkTableCell *obj)
+{
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (obj), -1);
+  MyAtkTableCell *self = MY_ATK_TABLE_CELL (obj);
+  return self->row_span;
+}
+
+static gboolean
+my_atk_tablecell_get_position (AtkTableCell *obj, gint *row , gint *column)
+{
+  MyAtkTableCell *self = MY_ATK_TABLE_CELL (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (obj), FALSE);
+
+  *row = self->xy[0];
+  *column = self->xy[1];
+
+  return FALSE;
+}
+
+static GPtrArray *
+my_atk_tablecell_get_row_header_cells (AtkTableCell *obj)
+{
+  g_return_val_if_fail (MY_IS_ATK_TABLE_CELL (obj), FALSE);
+  MyAtkTable *tab = MY_ATK_TABLE (atk_object_get_parent (ATK_OBJECT (obj)));
+
+  gint i, all_child;
+  all_child = MY_ATK_OBJECT (tab)->children->len;
+  AtkObject *child = NULL;
+  GPtrArray *ret = g_ptr_array_new_full (atk_table_get_n_columns ATK_TABLE (tab), g_object_unref);
+
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (tab), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER) {
+      g_ptr_array_add (ret, child);
+    }
+  }
+
+  return ret;
+}
+
+static void
+atk_tablecell_interface_init (AtkTableCellIface *iface)
+{
+  if (!iface) return;
+  iface->get_column_span = my_atk_tablecell_get_column_span;
+  iface->get_column_header_cells = my_atk_tablecell_get_column_header_cells;
+  iface->get_position = my_atk_tablecell_get_position;
+  iface->get_row_span = my_atk_tablecell_get_row_span;
+  iface->get_row_header_cells = my_atk_tablecell_get_row_header_cells;
+  iface->get_row_column_span = my_atk_tablecell_get_row_column_span;
+  iface->get_table = my_atk_tablecell_get_table;
+}
+
+static void
+my_atk_tablecell_init (MyAtkTableCell *self)
+{
+  self->value = NULL;
+  self->parent_table = NULL;
+  self->row_desc = NULL;
+  self->selected = FALSE;
+  memset (self->xy, -1, sizeof (self->xy));
+  self->column_span = 1;
+  self->row_span = 1;
+  self->x = -1;
+  self->y = -1;
+  self->column_index = -1;
+}
+
+static void
+my_atk_tablecell_class_initialize (AtkObject *obj, gpointer data)
+{
+}
+
+static void
+my_atk_tablecell_class_finalize (GObject *obj)
+{
+}
+
+static void
+my_atk_tablecell_class_init (MyAtkTableCellClass *my_class)
+{
+  AtkObjectClass *atk_class = ATK_OBJECT_CLASS (my_class);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (my_class);
+
+  gobject_class->finalize = my_atk_tablecell_class_finalize;
+
+  atk_class->initialize = my_atk_tablecell_class_initialize;
+}
diff --git a/tests/dummyatk/my-atk-table-cell.h b/tests/dummyatk/my-atk-table-cell.h
new file mode 100644
index 0000000..78f8dd0
--- /dev/null
+++ b/tests/dummyatk/my-atk-table-cell.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef MY_ATK_TABLE_CELL_H_
+#define MY_ATK_TABLE_CELL_H_
+
+#include <glib.h>
+#include <glib-object.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+#define MY_TYPE_ATK_TABLE_CELL                  (my_atk_tablecell_get_type ())
+#define MY_ATK_TABLE_CELL(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_ATK_TABLE_CELL, MyAtkTableCell))
+#define MY_ATK_TABLE_CELL_CLASS (vtablecell)    (G_TYPE_CHECK_CLASS_CAST ((vtablecell), MY_TYPE_ATK_TABLE_CELL, MyAtkTableCellClass))
+#define MY_IS_ATK_TABLE_CELL(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_ATK_TABLE_CELL))
+#define MY_IS_ATK_TABLE_CELL_CLASS (vtablecell) (G_TYPE_CHECK_CLASS_TYPE ((vtablecell), MY_TYPE_ATK_TABLE_CELL))
+#define MY_ATK_TABLE_CELL_GET_CLASS (inst)      (G_TYPE_INSTANCE_GET_CLASS ((inst), MY_TYPE_ATK_TABLE_CELL, MyAtkTableCellClass))
+
+typedef struct _MyAtkTableCell MyAtkTableCell;
+typedef struct _MyAtkTableCellClass MyAtkTableCellClass;
+
+struct _MyAtkTableCell {
+  MyAtkObject parent;
+  MyAtkObject *parent_table;
+  gpointer value;
+  gint x;
+  gint y;
+  gint column_span;
+  gint row_span;
+  gint column_index;
+  gboolean selected;
+  gchar *row_desc;
+  gint xy[2];
+};
+
+struct _MyAtkTableCellClass {
+  MyAtkObjectClass parent;
+};
+
+GType my_atk_tablecell_get_type (void);
+
+gboolean my_atk_set_table_cell (AtkTableCell *self, gint x, gint y, gint row, gint column);
+gboolean my_atk_set_tablecell (MyAtkTableCell *self, gpointer value, const gchar *row_desc, MyAtkObject *parent_table, gboolean selected, gint *xy);
+
+#endif /* MY_ATK_TABLE_CELL_H_ */
diff --git a/tests/dummyatk/my-atk-table.c b/tests/dummyatk/my-atk-table.c
new file mode 100644
index 0000000..58fd1bd
--- /dev/null
+++ b/tests/dummyatk/my-atk-table.c
@@ -0,0 +1,682 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <glib.h>
+#include <string.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+#include "my-atk-table.h"
+#include "my-atk-table-cell.h"
+
+typedef struct _MyAtkTableInfo MyAtkTableInfo;
+
+static void GDestroyNotifyGPTRARRAYptrArray (gpointer data);
+static void atk_table_interface_init (AtkTableIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (MyAtkTable,
+                         my_atk_table,
+                         MY_TYPE_ATK_OBJECT,
+                         G_IMPLEMENT_INTERFACE (ATK_TYPE_TABLE,
+                             atk_table_interface_init));
+
+
+static gint
+my_atk_table_get_index_at (AtkTable *obj, gint row, gint column)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);
+  gint i, all_child, index_first_cell = -1;
+  gint ret = -1;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+
+  MyAtkTableCell *cell = NULL;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_CELL) {
+      if (index_first_cell == -1) {
+        index_first_cell = i;
+      }
+      cell = MY_ATK_TABLE_CELL (child);
+      if (cell->x == column && cell->y == row) {
+        ret = i-index_first_cell;
+      }
+    }
+  }
+  return ret;
+}
+
+static gint
+my_atk_table_get_column_at_index (AtkTable *obj, gint index)
+{
+  MyAtkTable *table = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);
+  gint columns = -1;
+  gint rows = -1;
+  gint i, j;
+
+  columns = atk_table_get_n_columns (ATK_TABLE (table));
+  rows = atk_table_get_n_rows (ATK_TABLE (table));
+
+  for (i = 0; i < rows; i++) {
+    for (j = 0; j < columns; j++) {
+      if (index == my_atk_table_get_index_at (obj, i, j))
+        return j;
+    }
+  }
+  return -1;
+}
+
+static gint
+my_atk_table_get_row_at_index (AtkTable *obj, gint index)
+{
+  MyAtkTable *table = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);
+  gint columns = -1;
+  gint rows = -1;
+  gint i, j;
+
+  columns = atk_table_get_n_columns (ATK_TABLE (table));
+  rows = atk_table_get_n_rows (ATK_TABLE (table));
+
+  for (i = 0; i < rows; i++) {
+    for (j = 0; j < columns; j++) {
+      if (index == my_atk_table_get_index_at (obj, i, j))
+        return i;
+    }
+  }
+
+  return -1;
+}
+
+static gint
+my_atk_table_get_n_columns (AtkTable *obj)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);
+  gint i, all_child, ret=0;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)
+      ret++;
+  }
+  return ret;
+}
+
+static gint
+my_atk_table_get_n_rows (AtkTable *obj)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);
+  gint i, all_child, ret=0;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)
+      ret++;
+  }
+  return ret;
+}
+
+static AtkObject*
+my_atk_table_get_caption (AtkTable *obj)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);
+  gint i, all_child;
+  AtkObject *caption = NULL;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_CAPTION)
+      caption = child;
+  }
+  return caption ? caption : NULL;
+}
+
+static AtkObject*
+my_atk_table_ref_at (AtkTable *obj, gint row, gint column)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);
+  gint i, all_child;
+  AtkObject *ret = NULL;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+
+  MyAtkTableCell *cell = NULL;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_CELL) {
+      cell = MY_ATK_TABLE_CELL (child);
+      if (cell->x == column && cell->y == row)
+        ret = ATK_OBJECT (cell);
+    }
+  }
+  return ret ? ret : NULL;
+}
+
+static const gchar *
+my_atk_table_get_row_description (AtkTable *obj, gint index)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);
+  gint i, all_child;
+  GPtrArray *ret = g_ptr_array_new_full ( my_atk_table_get_n_rows (obj),
+                                          g_object_unref);
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)
+      g_ptr_array_add (ret, child);
+  }
+  child = g_ptr_array_index (ret, index);
+
+  return g_strdup (atk_object_get_description (child));
+}
+
+static const gchar *
+my_atk_table_get_column_description (AtkTable *obj, gint index)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);
+  gint i, all_child;
+  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_columns (obj), g_object_unref);
+
+  all_child = MY_ATK_OBJECT(self)->children->len;
+  AtkObject *child = NULL;
+
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)
+      g_ptr_array_add (ret, child);
+  }
+  child = g_ptr_array_index (ret, index);
+
+  return g_strdup (atk_object_get_description (child));
+}
+
+static gint
+my_atk_table_test_table_get_row_extent_at (AtkTable *obj, gint row, gint col)
+{
+  AtkObject *cell = my_atk_table_ref_at (obj, row, col);
+
+  MyAtkTableCell *self = MY_ATK_TABLE_CELL (cell);
+
+  return self->row_span;
+}
+
+static gint
+my_atk_table_test_table_get_column_extent_at (AtkTable *obj, gint row, gint col)
+{
+  AtkObject *cell = my_atk_table_ref_at (obj, row, col);
+
+  MyAtkTableCell *self = MY_ATK_TABLE_CELL (cell);
+
+  return self->column_span;
+}
+
+static AtkObject*
+my_atk_table_get_row_header (AtkTable *obj, gint row)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);
+  gint i, all_child;
+  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_rows (obj), g_object_unref);
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+  AtkObject *c = NULL;
+
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)
+      g_ptr_array_add (ret, child);
+  }
+  c = ATK_OBJECT (g_ptr_array_index (ret, row));
+
+  return atk_object_ref_accessible_child (c, 0);
+}
+
+static AtkObject*
+my_atk_table_get_column_header (AtkTable *obj, gint col)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);
+  gint i, all_child;
+  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_rows (obj), g_object_unref);
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  AtkObject *child = NULL;
+  AtkObject *c = NULL;
+
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)
+      g_ptr_array_add (ret, child);
+  }
+  c = g_ptr_array_index (ret, col);
+
+  return atk_object_ref_accessible_child (c, 0);
+}
+
+gint
+my_atk_table_get_selected_rows (AtkTable *obj, gint **selected)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);
+  gint i, all_child, row = 0, ret = 0;
+  AtkObject *child = NULL;
+  AtkStateSet *ss = NULL;
+
+  GArray *array = g_array_new (FALSE, FALSE, sizeof (gint));
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i=0; i<all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER) {
+      ss = atk_object_ref_state_set (child);
+      if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED)) {
+        ret++;
+        g_array_append_val (array, row);
+      }
+      row++;
+    }
+  }
+  if (selected)
+    *selected = (gint *) g_array_free (array, FALSE);
+  return ret;
+}
+
+gint
+my_atk_table_get_selected_columns (AtkTable *obj, gint **selected)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), -1);
+  gint i, all_child, column = 0, ret = 0;
+  AtkObject *child = NULL;
+  AtkStateSet *ss = NULL;
+
+  GArray *array = g_array_new (FALSE, FALSE, sizeof (gint));
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i=0; i<all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER) {
+      ss = atk_object_ref_state_set (child);
+      if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED)) {
+        ret++;
+        g_array_append_val (array, column);
+      }
+      column++;
+    }
+  }
+  if (selected)
+    *selected = (gint *) g_array_free (array, FALSE);
+  return ret;
+}
+
+static gboolean
+my_atk_table_is_row_selected (AtkTable *obj, gint row)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);
+  gint i, all_child;
+  AtkObject *child = NULL;
+  AtkObject *c = NULL;
+  AtkStateSet *ss = NULL;
+  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_rows (obj), g_object_unref);
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER)
+      g_ptr_array_add (ret, child);
+  }
+  c = g_ptr_array_index (ret, row);
+  ss = atk_object_ref_state_set (c);
+  if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))
+    return TRUE;
+  return FALSE;
+}
+
+static gboolean
+my_atk_table_is_column_selected (AtkTable *obj, gint col)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);
+  gint i, all_child;
+  AtkObject *child = NULL;
+  AtkObject *c = NULL;
+  AtkStateSet *ss = NULL;
+  GPtrArray *ret = g_ptr_array_new_full (my_atk_table_get_n_columns (obj), g_object_unref);
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER)
+      g_ptr_array_add (ret, child);
+  }
+  c = g_ptr_array_index (ret, col);
+  ss = atk_object_ref_state_set (c);
+  if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))
+    return TRUE;
+  return FALSE;
+}
+
+static gboolean
+my_atk_table_is_selected (AtkTable *obj, gint row, gint col)
+{
+  AtkObject *cell = atk_table_ref_at (obj, row, col);
+  AtkStateSet *ss = atk_object_ref_state_set (cell);
+  gboolean ret = FALSE;
+
+  if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED))
+    ret = TRUE;
+  return ret;
+}
+
+static gboolean
+my_atk_table_add_column_selection (AtkTable *obj, gint col)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);
+  gint i, all_child, counter = 0;
+  AtkObject *child = NULL;
+  AtkStateSet *ss = NULL;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER) {
+      if (col == counter) {
+        ss = atk_object_ref_state_set (child);
+        if (!atk_state_set_contains_state (ss, ATK_STATE_SELECTED)) {
+          atk_state_set_add_state (ss, ATK_STATE_SELECTED);
+          return TRUE;
+        }
+      }
+      counter++;
+    }
+  }
+  return FALSE;
+}
+
+static gboolean
+my_atk_table_add_row_selection (AtkTable *obj, gint row)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);
+  gint i, all_child, counter = 0;
+  AtkObject *child = NULL;
+  AtkStateSet *ss = NULL;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER) {
+      if (row == counter) {
+        ss = atk_object_ref_state_set (child);
+        if (!atk_state_set_contains_state (ss, ATK_STATE_SELECTED)) {
+          atk_state_set_add_state (ss, ATK_STATE_SELECTED);
+          return TRUE;
+        }
+      }
+      counter++;
+    }
+  }
+  return FALSE;
+}
+
+static gboolean
+my_atk_table_remove_column_selection (AtkTable *obj, gint col)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);
+  gint i, all_child, counter = 0;
+  AtkObject *child = NULL;
+  AtkStateSet *ss = NULL;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_COLUMN_HEADER) {
+      if (col == counter) {
+        ss = atk_object_ref_state_set (child);
+        if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED)) {
+          atk_state_set_remove_state (ss, ATK_STATE_SELECTED);
+          return TRUE;
+        }
+      }
+      counter++;
+    }
+  }
+  return FALSE;
+}
+
+static gboolean
+my_atk_table_remove_row_selection (AtkTable *obj, gint row)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), FALSE);
+  gint i, all_child, counter = 0;
+  AtkObject *child = NULL;
+  AtkStateSet *ss = NULL;
+
+  all_child = MY_ATK_OBJECT (self)->children->len;
+  for (i = 0; i < all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_TABLE_ROW_HEADER) {
+      if (row == counter) {
+        ss = atk_object_ref_state_set (child);
+        if (atk_state_set_contains_state (ss, ATK_STATE_SELECTED)) {
+          atk_state_set_remove_state (ss, ATK_STATE_SELECTED);
+          return TRUE;
+        }
+      }
+      counter++;
+    }
+  }
+  return FALSE;
+}
+
+static AtkObject *
+my_atk_table_get_summary (AtkTable *obj)
+{
+  MyAtkTable *self = MY_ATK_TABLE (obj);
+  g_return_val_if_fail (MY_IS_ATK_TABLE (obj), NULL);
+  gint i, all_child;
+  AtkObject *summary = NULL;
+
+  all_child = MY_ATK_OBJECT(self)->children->len;
+  AtkObject *child = NULL;
+  for (i=0; i<all_child; i++) {
+    child = atk_object_ref_accessible_child (ATK_OBJECT (obj), i);
+    if (atk_object_get_role (child) == ATK_ROLE_HEADING)
+      summary = child;
+  }
+  return summary ? summary : NULL;
+}
+
+static void
+my_atk_table_set_column_header (AtkTable *obj, gint column, AtkObject *header)
+{
+}
+
+static void
+my_atk_table_set_column_description (AtkTable *obj, gint column, const gchar *desc)
+{
+}
+
+static void
+my_atk_table_set_caption (AtkTable *obj, AtkObject *caption)
+{
+}
+
+static void
+my_atk_table_set_row_description (AtkTable *obj, gint row, const gchar *desc)
+{
+}
+
+static void
+my_atk_table_set_row_header (AtkTable *obj, gint column, AtkObject *header)
+{
+}
+
+static void
+my_atk_table_set_summary (AtkTable *table, AtkObject *accessible)
+{
+}
+
+static void
+my_atk_table_row_inserted (AtkTable *table, gint row, gint num_inserted)
+{
+}
+
+static void
+my_atk_table_column_inserted (AtkTable *table, gint column, gint num_inserted)
+{
+}
+
+static void
+my_atk_table_row_deleted (AtkTable *table, gint row, gint num_deleted)
+{
+}
+
+static void
+my_atk_table_column_deleted (AtkTable *table, gint column, gint num_deleted)
+{
+}
+
+static void
+my_atk_table_row_reordered (AtkTable *table)
+{
+}
+
+static void
+my_atk_table_column_reordered (AtkTable *table)
+{
+}
+
+static void
+my_atk_table_model_changed (AtkTable *table)
+{
+}
+
+static void
+atk_table_interface_init (AtkTableIface *iface)
+{
+
+  if (!iface) return;
+
+  iface->ref_at = my_atk_table_ref_at;
+
+  /* DEPRICATED BUT NOT IN ATSPI */
+  iface->get_index_at = my_atk_table_get_index_at;
+  iface->get_column_at_index = my_atk_table_get_column_at_index;
+  iface->get_row_at_index = my_atk_table_get_row_at_index;
+  /* DEPRICATED */
+
+  iface->get_n_columns = my_atk_table_get_n_columns;
+  iface->get_n_rows = my_atk_table_get_n_rows;
+  iface->get_column_extent_at = my_atk_table_test_table_get_column_extent_at;
+  iface->get_row_extent_at = my_atk_table_test_table_get_row_extent_at;
+  iface->get_caption = my_atk_table_get_caption;
+  iface->get_column_description = my_atk_table_get_column_description;
+  iface->get_column_header = my_atk_table_get_column_header;
+  iface->get_row_description = my_atk_table_get_row_description;
+  iface->get_row_header = my_atk_table_get_row_header;
+  iface->get_summary = my_atk_table_get_summary;
+  iface->set_caption = my_atk_table_set_caption;
+  iface->set_column_description = my_atk_table_set_column_description;
+  iface->set_column_header = my_atk_table_set_column_header;
+  iface->set_row_description = my_atk_table_set_row_description;
+  iface->set_row_header = my_atk_table_set_row_header;
+  iface->set_summary = my_atk_table_set_summary;
+  iface->get_selected_columns = my_atk_table_get_selected_columns;
+  iface->get_selected_rows = my_atk_table_get_selected_rows;
+  iface->is_column_selected = my_atk_table_is_column_selected;
+  iface->is_row_selected = my_atk_table_is_row_selected;
+  iface->is_selected = my_atk_table_is_selected;
+  iface->add_row_selection = my_atk_table_add_row_selection;
+  iface->remove_row_selection = my_atk_table_remove_row_selection;
+  iface->add_column_selection = my_atk_table_add_column_selection;
+  iface->remove_column_selection = my_atk_table_remove_column_selection;
+  iface->row_inserted = my_atk_table_row_inserted;
+  iface->column_inserted = my_atk_table_column_inserted;
+  iface->row_deleted = my_atk_table_row_deleted;
+  iface->column_deleted = my_atk_table_column_deleted;
+  iface->row_reordered = my_atk_table_row_reordered;
+  iface->column_reordered = my_atk_table_column_reordered;
+  iface->model_changed = my_atk_table_model_changed;
+}
+
+static void
+my_atk_table_init (MyAtkTable *self)
+{
+  self->parent_table = NULL;
+  self->table = g_ptr_array_new_with_free_func (GDestroyNotifyGPTRARRAYptrArray);
+  self->row_header = g_ptr_array_new_with_free_func (GDestroyNotifyGPTRARRAYptrArray);
+  self->column_headers = g_ptr_array_new_with_free_func (GDestroyNotifyGPTRARRAYptrArray);
+  self->selected = FALSE;
+  self->col_desc = NULL;
+
+}
+
+static void
+GDestroyNotifyGPTRARRAYptrArray (gpointer data)
+{
+  g_ptr_array_free (data, TRUE);
+}
+
+static void
+my_atk_table_class_initialize (AtkObject *obj, gpointer data)
+{
+}
+
+static void
+my_atk_table_class_finalize (GObject *obj)
+{
+}
+
+static void
+my_atk_table_class_init (MyAtkTableClass *my_class)
+{
+  AtkObjectClass *atk_class = ATK_OBJECT_CLASS (my_class);
+  GObjectClass *gobject_class = G_OBJECT_CLASS (my_class);
+
+  gobject_class->finalize = my_atk_table_class_finalize;
+
+  atk_class->initialize = my_atk_table_class_initialize;
+}
diff --git a/tests/dummyatk/my-atk-table.h b/tests/dummyatk/my-atk-table.h
new file mode 100644
index 0000000..a3a0e35
--- /dev/null
+++ b/tests/dummyatk/my-atk-table.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2008 Codethink Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef MY_ATK_TABLE_H_
+#define MY_ATK_TABLE_H_
+
+#include <glib.h>
+#include <glib-object.h>
+#include <atk/atk.h>
+
+#include "my-atk-object.h"
+#define MY_TYPE_ATK_TABLE             (my_atk_table_get_type ())
+#define MY_ATK_TABLE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_ATK_TABLE, MyAtkTable))
+#define MY_ATK_TABLE_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), MY_TYPE_ATK_TABLE, MyAtkTableClass))
+#define MY_IS_ATK_TABLE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_ATK_TABLE))
+#define MY_IS_ATK_TABLE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), MY_TYPE_ATK_TABLE))
+#define MY_ATK_TABLE_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), MY_TYPE_ATK_TABLE, MyAtkTableClass))
+
+typedef struct _MyAtkTable MyAtkTable;
+typedef struct _MyAtkTableClass MyAtkTableClass;
+
+struct _MyAtkTable {
+  MyAtkObject parent;
+  MyAtkTable *parent_table;
+  GPtrArray *table;
+  GPtrArray *column_headers;
+  GPtrArray *row_headers;
+  GPtrArray *row_header;
+  gchar *col_desc;
+  gboolean selected;
+};
+
+struct _MyAtkTableClass {
+  MyAtkObjectClass parent;
+};
+
+GType my_atk_table_get_type (void);
+
+guint my_atk_set_table (AtkTable *obj,
+                        gchar *col_header,
+                        gchar *row_header,
+                        gchar *col_desc,
+                        gchar* row_desc,
+                        gchar *value,
+                        gboolean selected,
+                        gboolean selected_col);
+
+AtkObject*
+test_get_cell_from_table (AtkTable *obj, gint row);
+
+#endif /* MY_ATK_TABLE_H_ */
diff --git a/tests/dummyatk/my-atk.h b/tests/dummyatk/my-atk.h
index eab8b8f..ef13273 100644
--- a/tests/dummyatk/my-atk.h
+++ b/tests/dummyatk/my-atk.h
@@ -26,9 +26,15 @@
 #include "my-atk-action.h"
 #include "my-atk-object.h"
 #include "my-atk-component.h"
+#include "my-atk-document.h"
 #include "my-atk-editable-text.h"
+#include "my-atk-hyperlink.h"
+#include "my-atk-hypertext.h"
 #include "my-atk-image.h"
+#include "my-atk-table.h"
+#include "my-atk-table-cell.h"
 #include "my-atk-text.h"
+#include "my-atk-selection.h"
 #include "my-atk-value.h"
 
 #endif /*MY_ATK_H*/