install_data(files(['testdiff.diff', 'testfile-windows.txt', 'testfile-withblanks.txt', 'testfile.txt']),
install_dir : join_paths(dir_data, 'elementary')
)
+subdir('spec')
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Efl_Ui.h>
+#include "efl_ui_spec_suite.h"
+#include "suite_helpers.h"
+
+void
+efl_test_container_content_equal(Efl_Ui_Widget **wid, unsigned int len)
+{
+ Efl_Ui_Widget *c;
+ Eina_Iterator *iter;
+ unsigned int i;
+ Eina_List *tmp = NULL;
+
+ ck_assert_int_eq(efl_content_count(widget), len);
+ iter = efl_content_iterate(widget);
+ EINA_ITERATOR_FOREACH(iter, c)
+ {
+ ck_assert_ptr_eq(eina_list_data_find(tmp, c), NULL);
+ tmp = eina_list_append(tmp, c);
+ }
+ eina_iterator_free(iter);
+ for (i = 0; i < len; ++i)
+ {
+ ck_assert_ptr_ne(eina_list_data_find(tmp, wid[i]), NULL);
+ tmp = eina_list_remove(tmp, wid[i]);
+ }
+ ck_assert_int_eq(eina_list_count(tmp), 0);
+}
+
+typedef struct {
+ Eina_Bool *flag;
+ void *expected_event_data;
+} Efl_Container_Event_Content;
+
+static void
+_evt_called(void *data, const Efl_Event *ev)
+{
+ Efl_Container_Event_Content *content = data;
+
+ *content->flag = EINA_TRUE;
+ ck_assert_ptr_eq(content->expected_event_data, ev->info);
+ efl_event_callback_del(ev->object, ev->desc, _evt_called, data);
+ free(data);
+}
+
+void
+efl_test_container_expect_evt_content_added(Efl_Ui_Widget *widget, const Efl_Event_Description *ev, Eina_Bool *flag, void *event_data)
+{
+ Efl_Container_Event_Content *c = calloc(1, sizeof(Efl_Container_Event_Content));
+ c->flag = flag;
+ c->expected_event_data = event_data;
+ efl_event_callback_add(widget, ev, _evt_called, c);
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Efl_Ui.h>
+#include "efl_ui_spec_suite.h"
+#include "suite_helpers.h"
+
+/*
+ In general:
+ - If a subobject is deleted the box simply forgets about it. Never return this element again container.
+*/
+
+EFL_START_TEST(base2)
+{
+ ck_assert(win);
+ ck_assert(widget);
+}
+EFL_END_TEST
+
+static void
+_setup_std_pack(Efl_Ui_Widget *wid[3])
+{
+ unsigned int i;
+
+ for (i = 0; i < 3; ++i)
+ {
+ wid[i] = efl_add(WIDGET_CLASS, widget);
+ ck_assert_int_eq(efl_pack(widget, wid[i]), EINA_TRUE);
+ efl_gfx_entity_visible_set(widget, EINA_TRUE);
+ }
+}
+
+/*
+ pack_clear function:
+ - each element must be deleted after the call
+ - the container must have 0 contents after the call
+ - the call must return true even if the container is empty
+*/
+
+EFL_START_TEST(pack_clear1)
+{
+ Efl_Ui_Widget *wid[3];
+ unsigned int i;
+
+ _setup_std_pack(wid);
+
+ for (i = 0; i < sizeof(wid)/sizeof(Efl_Ui_Widget*); ++i)
+ {
+ efl_wref_add(wid[i], &wid[i]);
+ }
+
+ ck_assert_int_eq(efl_pack_clear(widget), EINA_TRUE);
+
+ for (i = 0; i < sizeof(wid)/sizeof(Efl_Ui_Widget*); ++i)
+ {
+ ck_assert_ptr_eq(wid[i], NULL);
+ }
+
+ efl_test_container_content_equal(NULL, 0);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_clear2)
+{
+ Efl_Ui_Widget *wid[3];
+
+ _setup_std_pack(wid);
+
+ ck_assert_int_eq(efl_pack_clear(widget), EINA_TRUE);
+ ck_assert_int_eq(efl_pack_clear(widget), EINA_TRUE);
+ ck_assert_int_eq(efl_pack_clear(widget), EINA_TRUE);
+ ck_assert_int_eq(efl_pack_clear(widget), EINA_TRUE);
+ ck_assert_int_eq(efl_pack_clear(widget), EINA_TRUE);
+}
+EFL_END_TEST
+
+/*
+ unpack_all function:
+ - each element must have exactly one reference after the call
+ - the container must have 0 contents after the call
+ - the call must return true even if the container is empty
+*/
+
+EFL_START_TEST(unpack_all1)
+{
+ Efl_Ui_Widget *wid[3];
+ unsigned int i;
+
+ _setup_std_pack(wid);
+
+ ck_assert_int_eq(efl_pack_unpack_all(widget), EINA_TRUE);
+
+ for (i = 0; i < sizeof(wid)/sizeof(Efl_Ui_Widget*); ++i)
+ {
+ ck_assert_int_eq(efl_ref_count(wid[i]), 1);
+ }
+ efl_test_container_content_equal(NULL, 0);
+}
+EFL_END_TEST
+
+EFL_START_TEST(unpack_all2)
+{
+ Efl_Ui_Widget *wid[3];
+ unsigned int i;
+
+ _setup_std_pack(wid);
+
+ ck_assert_int_eq(efl_pack_unpack_all(widget), EINA_TRUE);
+ ck_assert_int_eq(efl_pack_clear(widget), EINA_TRUE);
+
+ for (i = 0; i < sizeof(wid)/sizeof(Efl_Ui_Widget*); ++i)
+ {
+ ck_assert_int_eq(efl_ref_count(wid[i]), 1);
+ }
+ efl_test_container_content_equal(NULL, 0);
+}
+EFL_END_TEST
+
+/*
+ unpack function:
+ - the element must have exactly one reference after the call
+ - the container must have one content less after the call
+ - the widget parent must be different from the parent
+ - unpacking something invalid can return EINA_FALSE but must not print an error
+*/
+
+EFL_START_TEST(unpack1)
+{
+ Efl_Ui_Widget *wid[3];
+ _setup_std_pack(wid);
+
+ ck_assert_int_eq(efl_pack_unpack(widget, wid[2]), EINA_TRUE);
+ ck_assert_ptr_ne(efl_ui_widget_parent_get(wid[2]), widget);
+ ck_assert_int_eq(efl_ref_count(wid[2]), 1);
+ efl_test_container_content_equal(wid, 2);
+}
+EFL_END_TEST
+
+EFL_START_TEST(unpack2)
+{
+ Efl_Ui_Widget *wid[3];
+ _setup_std_pack(wid);
+
+ ck_assert_int_eq(efl_pack_unpack(widget, wid[0]), EINA_TRUE);
+ ck_assert_int_eq(efl_pack(widget, wid[0]), EINA_TRUE);
+ ck_assert_int_eq(efl_pack_unpack(widget, wid[0]), EINA_TRUE);
+ ck_assert_int_eq(efl_pack(widget, wid[0]), EINA_TRUE);
+
+ efl_test_container_content_equal(wid, 3);
+}
+EFL_END_TEST
+
+EFL_START_TEST(unpack3)
+{
+ Efl_Ui_Widget *wid[3], *invalid;
+ _setup_std_pack(wid);
+
+ invalid = efl_add(WIDGET_CLASS, win);
+ ck_assert_int_eq(efl_pack_unpack(widget, wid[2]), EINA_TRUE);
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_unpack(widget, wid[2]), EINA_FALSE);
+ EXPECT_ERROR_END;
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_unpack(widget, wid[2]), EINA_FALSE);
+ EXPECT_ERROR_END;
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_unpack(widget, (Eo*)0x111), EINA_FALSE);
+ EXPECT_ERROR_END;
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_unpack(widget, invalid), EINA_FALSE);
+ EXPECT_ERROR_END;
+ efl_test_container_content_equal(wid, 2);
+}
+EFL_END_TEST
+
+/*
+ pack function:
+ - element must be added to the content of the container
+ - elements widget_parent must be the container
+ - double adding a widdget must error
+ - adding something invalid must error
+*/
+
+EFL_START_TEST(pack1)
+{
+ Efl_Ui_Widget *wid[3];
+ unsigned int i;
+
+ _setup_std_pack(wid);
+
+ for (i = 0; i < sizeof(wid)/sizeof(Efl_Ui_Widget*); ++i)
+ {
+ ck_assert_int_eq(efl_ref_count(wid[i]), 1);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(wid[i]), widget);
+ }
+
+ efl_test_container_content_equal(wid, 3);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack2)
+{
+ Efl_Ui_Widget *wid[3];
+ _setup_std_pack(wid);
+
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack(widget, wid[0]), EINA_FALSE);
+ EXPECT_ERROR_END;
+ efl_test_container_content_equal(wid, 3);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack3)
+{
+ Efl_Ui_Widget *wid[3];
+ _setup_std_pack(wid);
+
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack(widget, (Eo*)0x111F), EINA_FALSE);
+ EXPECT_ERROR_END;
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack(widget, widget), EINA_FALSE);
+ EXPECT_ERROR_END;
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack(widget, NULL), EINA_FALSE);
+ EXPECT_ERROR_END;
+ efl_test_container_content_equal(wid, 3);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_align)
+{
+#define TUPLE_CHECK(H,V,rh,rv) \
+ do { \
+ double v, h; \
+ efl_pack_align_set(widget, H, V); \
+ efl_pack_align_get(widget, &h, &v); \
+ ck_assert(v == rv); \
+ ck_assert(h == rh); \
+ } while(0);
+
+ TUPLE_CHECK( 1.0, 1.0, 1.0, 1.0);
+ TUPLE_CHECK( 0.0, 0.0, 0.0, 0.0);
+ TUPLE_CHECK(- 1.0, - 1.0, -1.0, -1.0);
+ TUPLE_CHECK(-42.0, -42.0, -1.0, -1.0);
+ TUPLE_CHECK( 42.0, 42.0, 1.0, 1.0);
+ TUPLE_CHECK(-42.0, 42.0, -1.0, 1.0);
+ TUPLE_CHECK( 42.0, -42.0, 1.0, -1.0);
+#undef TUPLE_CHECK
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_padding)
+{
+#define TUPLE_CHECK(H, V, rh, rv, S, rs) \
+ do { \
+ double v, h; \
+ Eina_Bool r; \
+ efl_pack_padding_set(widget, H, V, S); \
+ efl_pack_padding_get(widget, &h, &v, &r); \
+ ck_assert(v == rv); \
+ ck_assert(h == rh); \
+ ck_assert_int_eq(r, S); \
+ } while(0);
+
+ TUPLE_CHECK( 0.0, 0.0, 0.0, 0.0, EINA_TRUE, EINA_TRUE);
+ TUPLE_CHECK( -1.0, -123.0, 0.0, 0.0, EINA_FALSE, EINA_FALSE);
+ TUPLE_CHECK( -1.0, 123.0, 0.0, 123.0, EINA_FALSE, EINA_FALSE);
+#undef TUPLE_CHECK
+}
+EFL_END_TEST
+
+EFL_START_TEST(evt_content_added)
+{
+ Eina_Bool called = EINA_TRUE;
+ Efl_Ui_Widget *wid = efl_add(WIDGET_CLASS, win);
+ efl_test_container_expect_evt_content_added(widget, EFL_CONTAINER_EVENT_CONTENT_ADDED, &called, wid);
+ efl_pack(widget, wid);
+ ck_assert_int_eq(called, EINA_TRUE);
+}
+EFL_END_TEST
+
+EFL_START_TEST(evt_content_removed)
+{
+ Eina_Bool called = EINA_TRUE;
+ Efl_Ui_Widget *wid[3];
+
+ _setup_std_pack(wid);
+
+ efl_test_container_expect_evt_content_added(widget, EFL_CONTAINER_EVENT_CONTENT_REMOVED, &called, wid[1]);
+ efl_pack_unpack(widget, wid[1]);
+ ck_assert_int_eq(called, EINA_TRUE);
+}
+EFL_END_TEST
+
+EFL_START_TEST(child_killed)
+{
+ Efl_Ui_Widget *wid[3];
+ _setup_std_pack(wid);
+
+ efl_wref_add(wid[0], &wid[0]);
+ efl_del(wid[0]);
+ efl_test_container_content_equal(&wid[1], 2);
+ ck_assert_ptr_eq(wid[0], NULL);
+}
+EFL_END_TEST
+
+EFL_START_TEST(container_killed)
+{
+ Efl_Ui_Widget *wid[3];
+ unsigned int i = 0;
+
+ _setup_std_pack(wid);
+
+ for (i = 0; i < sizeof(wid)/sizeof(Efl_Ui_Widget*); ++i)
+ {
+ efl_wref_add(wid[i], &wid[i]);
+ }
+ efl_del(widget);
+ for (i = 0; i < sizeof(wid)/sizeof(Efl_Ui_Widget*); ++i)
+ {
+ ck_assert_ptr_eq(wid[i], NULL);
+ }
+}
+EFL_END_TEST
+
+void
+efl_pack_behavior_test(TCase *tc)
+{
+ tcase_add_test(tc, base2);
+ tcase_add_test(tc, pack_clear1);
+ tcase_add_test(tc, pack_clear2);
+ tcase_add_test(tc, unpack_all1);
+ tcase_add_test(tc, unpack_all2);
+ tcase_add_test(tc, unpack1);
+ tcase_add_test(tc, unpack2);
+ tcase_add_test(tc, unpack3);
+ tcase_add_test(tc, pack1);
+ tcase_add_test(tc, pack2);
+ tcase_add_test(tc, pack3);
+ tcase_add_test(tc, pack_align);
+ tcase_add_test(tc, pack_padding);
+ tcase_add_test(tc, evt_content_added);
+ tcase_add_test(tc, evt_content_removed);
+ tcase_add_test(tc, child_killed);
+ tcase_add_test(tc, container_killed);
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Efl_Ui.h>
+#include "efl_ui_spec_suite.h"
+#include "suite_helpers.h"
+#include <limits.h>
+
+static void
+_fill_array(Efl_Ui_Widget *wid[3])
+{
+ for (int i = 0; i < 3; ++i)
+ {
+ wid[i] = efl_add(WIDGET_CLASS, win);
+ }
+}
+
+static void
+_ordering_equals(Efl_Ui_Widget **wid, unsigned int len)
+{
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ ck_assert_ptr_eq(efl_pack_content_get(widget, i), wid[i]);
+ }
+ efl_test_container_content_equal(wid, len);
+}
+
+EFL_START_TEST(pack_begin1)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+
+ for (int i = 2; i >= 0; i--)
+ {
+ efl_pack_begin(widget, wid[i]);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(wid[i]), widget);
+ }
+ _ordering_equals(wid, 3);
+ efl_pack_begin(widget, inv);
+ ck_assert_ptr_eq(efl_pack_content_get(widget, 0), inv);
+ Efl_Ui_Widget *wid2[] = {inv, wid[0], wid[1], wid[2]};
+ _ordering_equals(wid2, 4);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_begin2)
+{
+ Efl_Ui_Widget *wid[3];
+
+ _fill_array(wid);
+
+ for (int i = 2; i >= 0; i--)
+ {
+ efl_pack_begin(widget, wid[i]);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(wid[i]), widget);
+ }
+
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_begin(widget, wid[0]), EINA_FALSE);
+ EXPECT_ERROR_END;
+ _ordering_equals(wid, 3);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_end1)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+
+ for (int i = 0; i < 3; i++)
+ {
+ efl_pack_end(widget, wid[i]);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(wid[i]), widget);
+ }
+
+ _ordering_equals(wid, 3);
+ efl_pack_end(widget, inv);
+ ck_assert_ptr_eq(efl_pack_content_get(widget, 3), inv);
+ Efl_Ui_Widget *wid2[] = {wid[0], wid[1], wid[2], inv};
+ _ordering_equals(wid2, 4);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_end2)
+{
+ Efl_Ui_Widget *wid[3];
+
+ _fill_array(wid);
+
+ for (int i = 0; i < 3; i++)
+ {
+ efl_pack_end(widget, wid[i]);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(wid[i]), widget);
+ }
+
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_end(widget, wid[0]), EINA_FALSE);
+ EXPECT_ERROR_END;
+ _ordering_equals(wid, 3);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_before1)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ ck_assert_int_eq(efl_pack_before(widget, inv, wid[0]), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+ Efl_Ui_Widget *wid2[] = {inv, wid[0], wid[1], wid[2]};
+ _ordering_equals(wid2, 4);
+ efl_pack_unpack(widget, inv);
+
+ ck_assert_int_eq(efl_pack_before(widget, inv, wid[2]), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+ Efl_Ui_Widget *wid3[] = {wid[0], wid[1], inv, wid[2]};
+ _ordering_equals(wid3, 4);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_before2)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ ck_assert_int_eq(efl_pack_before(widget, inv, wid[0]), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+ Efl_Ui_Widget *wid2[] = {inv, wid[0], wid[1], wid[2]};
+ _ordering_equals(wid2, 4);
+
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_before(widget, inv, wid[2]), EINA_FALSE);
+ EXPECT_ERROR_END;
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_after1)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ ck_assert_int_eq(efl_pack_after(widget, inv, wid[0]), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+ Efl_Ui_Widget *wid2[] = {wid[0], inv, wid[1], wid[2]};
+ _ordering_equals(wid2, 4);
+ efl_pack_unpack(widget, inv);
+
+ ck_assert_int_eq(efl_pack_after(widget, inv, wid[2]), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+ Efl_Ui_Widget *wid3[] = {wid[0], wid[1], wid[2], inv};
+ _ordering_equals(wid3, 4);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_after2)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ ck_assert_int_eq(efl_pack_after(widget, inv, wid[0]), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+ Efl_Ui_Widget *wid2[] = {wid[0], inv, wid[1], wid[2]};
+ _ordering_equals(wid2, 4);
+
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_after(widget, inv, wid[2]), EINA_FALSE);
+ EXPECT_ERROR_END;
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_at1)
+{
+ for (int x = -3; x < 3; ++x)
+ {
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+ unsigned int i;
+
+ _fill_array(wid);
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ efl_pack_at(widget, inv, x);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+
+ for (i = 0; i < 4; ++i)
+ {
+ Efl_Ui_Widget *w = efl_pack_content_get(widget, i);
+ unsigned int place_to_expect_inv = (3 + x) % 3;
+ if (i == place_to_expect_inv)
+ ck_assert_ptr_eq(w, inv);
+ else if (i < place_to_expect_inv)
+ ck_assert_ptr_eq(w, wid[i]);
+ else if (i > place_to_expect_inv)
+ ck_assert_ptr_eq(w, wid[i - 1]);
+ }
+ efl_pack_clear(widget);
+ }
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_at2)
+{
+ for (int x = -3; x < 3; ++x)
+ {
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+ unsigned int i;
+
+ _fill_array(wid);
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ ck_assert_int_eq(efl_pack_at(widget, inv, x), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+
+ EXPECT_ERROR_START;
+ ck_assert_int_eq(efl_pack_at(widget, inv, x - 1), EINA_FALSE);
+ EXPECT_ERROR_END;
+
+ for (i = 0; i < 4; ++i)
+ {
+ Efl_Ui_Widget *w = efl_pack_content_get(widget, i);
+ unsigned int place_to_expect_inv = (3 + x) % 3;
+ if (i == place_to_expect_inv)
+ ck_assert_ptr_eq(w, inv);
+ else if (i < place_to_expect_inv)
+ ck_assert_ptr_eq(w, wid[i]);
+ else if (i > place_to_expect_inv)
+ ck_assert_ptr_eq(w, wid[i - 1]);
+ }
+ efl_pack_clear(widget);
+ }
+}
+EFL_END_TEST
+
+
+EFL_START_TEST(pack_at3)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+ Efl_Ui_Widget *inv2 = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ ck_assert_int_eq(efl_pack_at(widget, inv,-100000), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv), widget);
+ ck_assert_int_eq(efl_pack_at(widget, inv2, 100000), EINA_TRUE);
+ ck_assert_ptr_eq(efl_ui_widget_parent_get(inv2), widget);
+ Efl_Ui_Widget *wid2[] = {inv, wid[0], wid[1], wid[2], inv2};
+ _ordering_equals(wid2, 5);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_content_get1)
+{
+ Efl_Ui_Widget *wid[3];
+
+ _fill_array(wid);
+
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+
+ for (int i = -100000; i <= 100000; i++)
+ {
+ if (i < -3)
+ ck_assert_ptr_eq(efl_pack_content_get(widget, i), efl_pack_content_get(widget, 0));
+ else if (i >= -3 && i < 3)
+ ck_assert_ptr_eq(efl_pack_content_get(widget, i), wid[(i + 3) % 3]);
+ else
+ ck_assert_ptr_eq(efl_pack_content_get(widget, i), efl_pack_content_get(widget, 2));
+ }
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_index_get1)
+{
+ Efl_Ui_Widget *wid[3];
+ Efl_Ui_Widget *inv = efl_add(WIDGET_CLASS, win);
+
+ _fill_array(wid);
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+ for (int i = 0; i < 3; i++)
+ ck_assert_int_eq(efl_pack_index_get(widget, wid[i]), i);
+
+ ck_assert_int_eq(efl_pack_index_get(widget, (void*)0xAFFE), -1);
+ ck_assert_int_eq(efl_pack_index_get(widget, inv), -1);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_unpack_at1)
+{
+ Efl_Ui_Widget *wid[3];
+
+ _fill_array(wid);
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+ for (int i = 0; i < 3; i++)
+ ck_assert_int_eq(efl_pack_index_get(widget, wid[i]), i);
+
+ ck_assert_ptr_eq(efl_pack_unpack_at(widget, 1), wid[1]);
+ Efl_Ui_Widget *wid1[] = {wid[0], wid[2]};
+ _ordering_equals(wid1, 2);
+ ck_assert_ptr_eq(efl_pack_unpack_at(widget, 1), wid[2]);
+ Efl_Ui_Widget *wid2[] = {wid[0]};
+ _ordering_equals(wid2, 1);
+ ck_assert_ptr_eq(efl_pack_unpack_at(widget, 0), wid[0]);
+ Efl_Ui_Widget *wid3[] = {};
+ _ordering_equals(wid3, 0);
+}
+EFL_END_TEST
+
+
+EFL_START_TEST(pack_unpack_at2)
+{
+ Efl_Ui_Widget *wid[3];
+
+ _fill_array(wid);
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+ for (int i = 0; i < 3; i++)
+ ck_assert_int_eq(efl_pack_index_get(widget, wid[i]), i);
+
+ ck_assert_ptr_eq(efl_pack_unpack_at(widget, 1), wid[1]);
+ efl_del(widget);
+ ck_assert_int_eq(efl_ref_count(wid[1]), 1);
+ ck_assert_int_eq(efl_ref_count(widget), 0);
+}
+EFL_END_TEST
+
+EFL_START_TEST(pack_unpack_at3)
+{
+ for (int x = -3; x < 3; ++x)
+ {
+ Efl_Ui_Widget *wid[3];
+
+ _fill_array(wid);
+ for (int i = 0; i < 3; i++)
+ efl_pack_end(widget, wid[i]);
+ ck_assert_ptr_eq(efl_pack_unpack_at(widget, x), wid[(3+x)%3]);
+ ck_assert_int_eq(efl_content_count(widget), 2);
+ ck_assert_ptr_ne(efl_ui_widget_parent_get(wid[(3+x)%3]), widget);
+ efl_pack_unpack_all(widget);
+ }
+}
+EFL_END_TEST
+
+void
+efl_pack_linear_behavior_test(TCase *tc)
+{
+ tcase_add_test(tc, pack_begin1);
+ tcase_add_test(tc, pack_begin2);
+ tcase_add_test(tc, pack_end1);
+ tcase_add_test(tc, pack_end2);
+ tcase_add_test(tc, pack_before1);
+ tcase_add_test(tc, pack_before2);
+ tcase_add_test(tc, pack_after1);
+ tcase_add_test(tc, pack_after2);
+ tcase_add_test(tc, pack_at1);
+ tcase_add_test(tc, pack_at2);
+ tcase_add_test(tc, pack_at3);
+ tcase_add_test(tc, pack_content_get1);
+ tcase_add_test(tc, pack_index_get1);
+ tcase_add_test(tc, pack_unpack_at1);
+ tcase_add_test(tc, pack_unpack_at2);
+ tcase_add_test(tc, pack_unpack_at3);
+ efl_pack_behavior_test(tc);
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+
+#include <Efl_Ui.h>
+#include "efl_ui_spec_suite.h"
+#include "suite_helpers.h"
+#include "eo_internal.h"
+
+Evas_Object *win = NULL;
+Evas_Object *widget = NULL;
+
+EFL_CLASS_SIMPLE_CLASS(efl_ui_widget, "efl_ui_widget", EFL_UI_WIDGET_CLASS);
+
+static int tree_abort;
+static int tree_abort_level;
+
+static void
+_shutdown(void)
+{
+ eina_log_abort_on_critical_set(tree_abort);
+ eina_log_abort_on_critical_level_set(tree_abort_level);
+}
+
+static void
+_setup(void)
+{
+ tree_abort = eina_log_abort_on_critical_get();
+ tree_abort_level = eina_log_abort_on_critical_level_get();
+ eina_log_abort_on_critical_level_set(2);
+ eina_log_abort_on_critical_set(1);
+}
+
+static void
+_setup_window_and_widget(const Efl_Class *klass)
+{
+ ck_assert(!win);
+ ck_assert(!widget);
+
+ win = win_add();
+ widget = efl_add(klass, win);
+ efl_content_set(win, widget);
+
+ ck_assert(win);
+ ck_assert(widget);
+}
+
+#include "efl_ui_spec_suite_gen.x"
+int
+main(int argc, char **argv)
+{
+ int failed_count;
+
+#define LIST_DECL
+#include "efl_ui_spec_suite_gen.x"
+
+ if (!_efl_test_option_disp(argc, argv, etc))
+ return 0;
+
+ failed_count = suite_setup(EINA_FALSE);
+
+ failed_count += _efl_suite_build_and_run(argc - 1, (const char **)argv + 1,
+ "Efl_Ui_Spec", etc, SUITE_INIT_FN(elm2), SUITE_SHUTDOWN_FN(elm));
+
+ return (failed_count == 0) ? 0 : 255;
+}
--- /dev/null
+#ifndef EFL_UI_SUITE_H
+#define EFL_UI_SUITE_H
+
+#include <check.h>
+
+#define EFL_NOLEGACY_API_SUPPORT
+#include <Efl_Ui.h>
+#include "../efl_check.h"
+
+extern Evas_Object *win;
+extern Evas_Object *widget;
+
+void efl_pack_behavior_test(TCase *tc);
+void efl_pack_linear_behavior_test(TCase *tc);
+
+
+void efl_test_container_content_equal(Efl_Ui_Widget **wid, unsigned int len);
+void efl_test_container_expect_evt_content_added(Efl_Ui_Widget *widget, const Efl_Event_Description *ev, Eina_Bool *flag, void *event_data);
+
+Evas_Object * win_add();
+
+const Efl_Class* efl_ui_widget_realized_class_get(void);
+
+#define WIDGET_CLASS efl_ui_widget_realized_class_get()
+
+#endif
--- /dev/null
+#!/usr/bin/python
+
+tests = [
+ ["Efl.Pack_Linear" , "Efl.Ui.Box"],
+]
+
+fixture_gen_template = """
+static void
+_{}_fixture(void)
+{{
+ _setup_window_and_widget({});
+}}
+"""
+
+tcase_gen_template = """
+static void
+{}(TCase *tc)
+{{
+ tcase_add_checked_fixture(tc, _{}_fixture, NULL);
+ tcase_add_checked_fixture(tc, _setup, _shutdown);
+ {}(tc);
+}}
+
+"""
+
+file_gen_template = """
+#ifdef LIST_DECL
+ {}
+#else
+ {}
+#endif
+"""
+
+import sys
+
+list_of_tcases = "static const Efl_Test_Case etc[] = {\n"
+list_entry = " {{ \"{}-{}\", {}}},\n"
+generated_api = ""
+
+def interface_to_api(interface_name):
+ return interface_name+"_behavior_test"
+
+def to_func_name(class_name):
+ return class_name.replace('.','_').lower()
+
+def to_class_getter(class_name):
+ return class_name.replace('.','_').upper()+'_CLASS'
+
+widgets = []
+
+for test in tests:
+ interface_test = to_func_name(test[0])
+ for widget_class in test[1:]:
+ combo_name = "_{}_{}".format(to_func_name(interface_test), to_func_name(widget_class));
+ list_of_tcases += list_entry.format(interface_test, to_func_name(widget_class), combo_name)
+ generated_api += tcase_gen_template.format(combo_name, to_func_name(widget_class), interface_to_api(interface_test))
+ if widget_class not in widgets:
+ widgets += [widget_class]
+
+for widget in widgets:
+ generated_api = fixture_gen_template.format(to_func_name(widget), to_class_getter(widget)) + generated_api
+
+list_of_tcases += " { NULL, NULL }\n};"
+
+output = open(sys.argv[1], "w")
+output.write(file_gen_template.format(list_of_tcases, generated_api))
--- /dev/null
+efl_ui_suite_behavior_src = [
+ join_paths('..','suite_helpers.c'),
+ join_paths('..','suite_helpers.h'),
+ join_paths('..','elm_test_init.c'),
+ 'efl_ui_spec_suite.c',
+ 'efl_test_pack.c',
+ 'efl_test_pack_linear.c',
+ 'efl_test_container.c',
+]
+
+test_generator = find_program('generator.py')
+
+generated_test_parts = custom_target('generate_test_suite',
+ output: 'efl_ui_spec_suite_gen.x',
+ command: [test_generator, '@OUTPUT@'],
+)
+
+efl_ui_behavior_suite = executable('efl_ui_spec_suite',
+ efl_ui_suite_behavior_src + [generated_test_parts],
+ dependencies: [check, eina, elementary, elementary_deps],
+ include_directories : [config_dir] + [elementary_config_dir] + [include_directories('../')],
+ c_args : [
+ '-DTESTS_BUILD_DIR="'+meson.current_build_dir()+'"',
+ '-DTESTS_SRC_DIR="'+meson.current_source_dir()+'"',
+ '-DELM_IMAGE_DATA_DIR="'+join_paths(meson.source_root(), 'data', 'elementary')+'"',
+ '-DELM_TEST_DATA_DIR="'+join_paths(meson.build_root(), 'data', 'elementary')+'"',
+ ]
+)
+
+test('efl_ui_spec-suite', efl_ui_behavior_suite,
+ env : test_env
+)