58 files changed, 632 insertions, 642 deletions

diff --git a/src/tests/ecore/ecore_test_animator.c b/src/tests/ecore/ecore_test_animator.c
index 98c7192..e2f17bc 100644
--- a/src/tests/ecore/ecore_test_animator.c
+++ b/src/tests/ecore/ecore_test_animator.c
@@ -30,7 +30,7 @@ START_TEST(ecore_test_animators)
    fail_if(!ecore_init(), "ERROR: Cannot init Ecore!\n");
 
    ecore_animator_frametime_set(interval1);
-   animator = eo_add(ECORE_ANIMATOR_CLASS, NULL, ecore_animator_timeline_constructor(1, _anim_cb, &interval1));
+   animator = eo_add(ECORE_ANIMATOR_CLASS, NULL, ecore_animator_timeline_constructor(eoid, 1, _anim_cb, &interval1));
 
    fail_if(!animator);
 
@@ -38,7 +38,7 @@ START_TEST(ecore_test_animators)
 
    ecore_animator_frametime_set(interval2);
    prev = 0;
-   animator = eo_add(ECORE_ANIMATOR_CLASS, NULL, ecore_animator_timeline_constructor(1, _anim_cb, &interval2));
+   animator = eo_add(ECORE_ANIMATOR_CLASS, NULL, ecore_animator_timeline_constructor(eoid, 1, _anim_cb, &interval2));
    fail_if(!animator);
 
    ecore_main_loop_begin();
diff --git a/src/tests/ecore/ecore_test_ecore_audio.c b/src/tests/ecore/ecore_test_ecore_audio.c
index fe2f325..0240903 100644
--- a/src/tests/ecore/ecore_test_ecore_audio.c
+++ b/src/tests/ecore/ecore_test_ecore_audio.c
@@ -34,7 +34,7 @@ static Eina_Bool _finished_cb(void *data EINA_UNUSED, const Eo_Event *event EINA
 
 static Eina_Bool _looped_cb(void *data EINA_UNUSED, const Eo_Event *event)
 {
-  eo_do(event->obj, ecore_audio_obj_in_looped_set(EINA_FALSE));
+  ecore_audio_obj_in_looped_set(event->obj, EINA_FALSE);
 
   return EINA_TRUE;
 }
@@ -47,10 +47,10 @@ _seek_vol(void *data)
    Eo *in = data;
    Eo *out = NULL;
 
-   eo_do(in, out = ecore_audio_obj_in_output_get());
+   out = ecore_audio_obj_in_output_get(in);
 
-   eo_do(out, ecore_audio_obj_volume_set(0.4));
-   eo_do(in, len = ecore_audio_obj_in_seek(-0.3, SEEK_END));
+   ecore_audio_obj_volume_set(out, 0.4);
+   len = ecore_audio_obj_in_seek(in, -0.3, SEEK_END);
    fail_if(len < 0);
 
    return EINA_FALSE;
@@ -65,8 +65,8 @@ START_TEST(ecore_test_ecore_audio_obj_pulse)
    in = eo_add(ECORE_AUDIO_IN_SNDFILE_CLASS, NULL);
    fail_if(!in);
 
-   eo_do(in, ecore_audio_obj_name_set("modem.wav"));
-   eo_do(in, ret = ecore_audio_obj_source_set(TESTS_SRC_DIR"/modem.wav"));
+   ecore_audio_obj_name_set(in, "modem.wav");
+   ret = ecore_audio_obj_source_set(in, TESTS_SRC_DIR"/modem.wav");
    fail_if(!ret);
 
    out = eo_add(ECORE_AUDIO_OUT_PULSE_CLASS, NULL);
@@ -74,10 +74,10 @@ START_TEST(ecore_test_ecore_audio_obj_pulse)
 
    ecore_timer_add(0.3, _seek_vol, in);
 
-   eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL));
-   eo_do(out, eo_event_callback_add(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_FAIL, _failed_cb, &pulse_context_failed));
+   eo_event_callback_add(in, ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL);
+   eo_event_callback_add(out, ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_FAIL, _failed_cb, &pulse_context_failed);
 
-   eo_do(out, ret = ecore_audio_obj_out_input_attach(in));
+   ret = ecore_audio_obj_out_input_attach(out, in);
    fail_if(!ret);
 
    ecore_main_loop_begin();
@@ -114,17 +114,17 @@ START_TEST(ecore_test_ecore_audio_cleanup)
 
    in = eo_add(ECORE_AUDIO_IN_TONE_CLASS, NULL);
    fail_if(!in);
-   eo_do(in, eo_key_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq));
-   eo_do(in, ecore_audio_obj_in_length_set(2));
+   eo_key_data_set(in, ECORE_AUDIO_ATTR_TONE_FREQ, &freq);
+   ecore_audio_obj_in_length_set(in, 2);
 
    out = eo_add(ECORE_AUDIO_OUT_SNDFILE_CLASS, NULL);
    fail_if(!out);
-   eo_do(out, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_OGG));
+   ret = ecore_audio_obj_format_set(out, ECORE_AUDIO_FORMAT_OGG);
    fail_if(!ret);
-   eo_do(out, ret = ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.ogg"));
+   ret = ecore_audio_obj_source_set(out, TESTS_BUILD_DIR"/tmp.ogg");
    fail_if(!ret);
 
-   eo_do(out, ret = ecore_audio_obj_out_input_attach(in));
+   ret = ecore_audio_obj_out_input_attach(out, in);
    fail_if(!ret);
 
    ecore_idler_add(_idle_del, in);
@@ -146,75 +146,75 @@ START_TEST(ecore_test_ecore_audio_obj_tone)
    in = eo_add(ECORE_AUDIO_IN_TONE_CLASS, NULL);
    fail_if(!in);
 
-   eo_do(in, ecore_audio_obj_name_set("tone"));
+   ecore_audio_obj_name_set(in, "tone");
 
-   eo_do(in, channel = ecore_audio_obj_in_channels_get());
+   channel = ecore_audio_obj_in_channels_get(in);
    fail_if(channel != 1);
-   eo_do(in, rate = ecore_audio_obj_in_samplerate_get());
+   rate = ecore_audio_obj_in_samplerate_get(in);
    fail_if(rate != 44100);
-   eo_do(in, len = ecore_audio_obj_in_length_get());
+   len = ecore_audio_obj_in_length_get(in);
    fail_if(len != 1);
 
-   eo_do(in, ecore_audio_obj_in_length_set(2.5));
-   eo_do(in, len = ecore_audio_obj_in_length_get());
+   ecore_audio_obj_in_length_set(in, 2.5);
+   len = ecore_audio_obj_in_length_get(in);
    fail_if(len != 2.5);
 
-   eo_do(in, ecore_audio_obj_in_looped_set(EINA_TRUE));
+   ecore_audio_obj_in_looped_set(in, EINA_TRUE);
 
-   eo_do(in, len = ecore_audio_obj_in_remaining_get());
+   len = ecore_audio_obj_in_remaining_get(in);
    fail_if(len != 2.5);
 
-   eo_do(in, freq = (intptr_t) eo_key_data_get(ECORE_AUDIO_ATTR_TONE_FREQ));
+   freq = (intptr_t) eo_key_data_get(in, ECORE_AUDIO_ATTR_TONE_FREQ);
    fail_if(freq != 1000);
 
    freq = 2000;
-   eo_do(in, eo_key_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq));
+   eo_key_data_set(in, ECORE_AUDIO_ATTR_TONE_FREQ, &freq);
 
-   eo_do(in, freq = (intptr_t) eo_key_data_get(ECORE_AUDIO_ATTR_TONE_FREQ));
+   freq = (intptr_t) eo_key_data_get(in, ECORE_AUDIO_ATTR_TONE_FREQ);
    fail_if(freq != 2000);
 
-   eo_do(in, eo_key_data_set("foo", "bar"));
-   eo_do(in, tmp = eo_key_data_get("foo"));
+   eo_key_data_set(in, "foo", "bar");
+   tmp = eo_key_data_get(in, "foo");
    ck_assert_str_eq(tmp, "bar");
 
-   eo_do(in, len = ecore_audio_obj_in_seek(5.0, SEEK_SET));
+   len = ecore_audio_obj_in_seek(in, 5.0, SEEK_SET);
    fail_if(len != -1);
 
-   eo_do(in, len = ecore_audio_obj_in_seek(1.0, 42));
+   len = ecore_audio_obj_in_seek(in, 1.0, 42);
    fail_if(len != -1);
 
-   eo_do(in, len = ecore_audio_obj_in_seek(1.0, SEEK_SET));
+   len = ecore_audio_obj_in_seek(in, 1.0, SEEK_SET);
    fail_if(len != 1.0);
 
-   eo_do(in, len = ecore_audio_obj_in_remaining_get());
+   len = ecore_audio_obj_in_remaining_get(in);
    fail_if(len != 1.5);
 
-   eo_do(in, len = ecore_audio_obj_in_seek(1.0, SEEK_CUR));
+   len = ecore_audio_obj_in_seek(in, 1.0, SEEK_CUR);
    fail_if(len != 2.0);
 
-   eo_do(in, len = ecore_audio_obj_in_remaining_get());
+   len = ecore_audio_obj_in_remaining_get(in);
    fail_if(len != 0.5);
 
-   eo_do(in, len = ecore_audio_obj_in_seek(-1.0, SEEK_END));
+   len = ecore_audio_obj_in_seek(in, -1.0, SEEK_END);
    fail_if(len != 1.5);
 
-   eo_do(in, len = ecore_audio_obj_in_remaining_get());
+   len = ecore_audio_obj_in_remaining_get(in);
    fail_if(len != 1.0);
 
    out = eo_add(ECORE_AUDIO_OUT_SNDFILE_CLASS, NULL);
    fail_if(!out);
 
-   eo_do(out, ecore_audio_obj_name_set("tmp.wav"));
-   eo_do(out, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_WAV));
+   ecore_audio_obj_name_set(out, "tmp.wav");
+   ret = ecore_audio_obj_format_set(out, ECORE_AUDIO_FORMAT_WAV);
    fail_if(!ret);
-   eo_do(out, ret = ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.wav"));
+   ret = ecore_audio_obj_source_set(out, TESTS_BUILD_DIR"/tmp.wav");
    fail_if(!ret);
 
-   eo_do(out, ret = ecore_audio_obj_out_input_attach(in));
+   ret = ecore_audio_obj_out_input_attach(out, in);
    fail_if(!ret);
 
-   eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_LOOPED, _looped_cb, NULL));
-   eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL));
+   eo_event_callback_add(in, ECORE_AUDIO_IN_EVENT_IN_LOOPED, _looped_cb, NULL);
+   eo_event_callback_add(in, ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL);
 
    ecore_main_loop_begin();
 
@@ -238,73 +238,73 @@ START_TEST(ecore_test_ecore_audio_obj_sndfile)
    in = eo_add(ECORE_AUDIO_IN_SNDFILE_CLASS, NULL);
    fail_if(!in);
 
-   eo_do(in, fmt = ecore_audio_obj_format_get());
+   fmt = ecore_audio_obj_format_get(in);
    fail_if(fmt != ECORE_AUDIO_FORMAT_AUTO);
 
-   eo_do(in, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_FLAC));
+   ret = ecore_audio_obj_format_set(in, ECORE_AUDIO_FORMAT_FLAC);
    fail_if(!ret);
 
-   eo_do(in, fmt = ecore_audio_obj_format_get());
+   fmt = ecore_audio_obj_format_get(in);
    fail_if(fmt != ECORE_AUDIO_FORMAT_FLAC);
 
-   eo_do(in, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_AUTO));
+   ret = ecore_audio_obj_format_set(in, ECORE_AUDIO_FORMAT_AUTO);
    fail_if(!ret);
 
-   eo_do(in, ecore_audio_obj_name_set("sms.ogg"));
-   eo_do(in, ret = ecore_audio_obj_source_set(TESTS_SRC_DIR"/sms.ogg"));
+   ecore_audio_obj_name_set(in, "sms.ogg");
+   ret = ecore_audio_obj_source_set(in, TESTS_SRC_DIR"/sms.ogg");
    fail_if(!ret);
 
-   eo_do(in, src = ecore_audio_obj_source_get());
+   src = ecore_audio_obj_source_get(in);
    ck_assert_str_eq(src, TESTS_SRC_DIR"/sms.ogg");
 
-   eo_do(in, fmt = ecore_audio_obj_format_get());
+   fmt = ecore_audio_obj_format_get(in);
    fail_if(fmt != ECORE_AUDIO_FORMAT_OGG);
 
-   eo_do(in, channel = ecore_audio_obj_in_channels_get());
+   channel = ecore_audio_obj_in_channels_get(in);
    fail_if(channel != 2);
-   eo_do(in, rate = ecore_audio_obj_in_samplerate_get());
+   rate = ecore_audio_obj_in_samplerate_get(in);
    fail_if(rate != 44100);
-   eo_do(in, len = ecore_audio_obj_in_length_get());
+   len = ecore_audio_obj_in_length_get(in);
    fail_if(len == 0);
-   eo_do(in, rem = ecore_audio_obj_in_remaining_get());
+   rem = ecore_audio_obj_in_remaining_get(in);
    fail_if(len != rem);
 
-   eo_do(in, fmt = ecore_audio_obj_format_get());
+   fmt = ecore_audio_obj_format_get(in);
    fail_if(fmt != ECORE_AUDIO_FORMAT_OGG);
 
-   eo_do(in, len = ecore_audio_obj_in_seek(0.5, SEEK_SET));
+   len = ecore_audio_obj_in_seek(in, 0.5, SEEK_SET);
    fail_if(len != 0.5);
 
-   eo_do(in, len = ecore_audio_obj_in_seek(0.5, SEEK_CUR));
+   len = ecore_audio_obj_in_seek(in, 0.5, SEEK_CUR);
    fail_if(len != 1.0);
 
-   eo_do(in, len = ecore_audio_obj_in_seek(-1.0, SEEK_END));
+   len = ecore_audio_obj_in_seek(in, -1.0, SEEK_END);
    fail_if(fabs(rem - 1 - len) > 0.1);
 
    out = eo_add(ECORE_AUDIO_OUT_SNDFILE_CLASS, NULL);
    fail_if(!out);
 
-   eo_do(out, ecore_audio_obj_name_set("tmp.wav"));
-   eo_do(out, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_WAV));
+   ecore_audio_obj_name_set(out, "tmp.wav");
+   ret = ecore_audio_obj_format_set(out, ECORE_AUDIO_FORMAT_WAV);
    fail_if(!ret);
 
-   eo_do(out, fmt = ecore_audio_obj_format_get());
+   fmt = ecore_audio_obj_format_get(out);
    fail_if(fmt != ECORE_AUDIO_FORMAT_WAV);
 
 
-//   eo_do(out, ret = ecore_audio_obj_source_set("/tmp/file/does/not/exist/hopefully.wav"));
+//   ret = ecore_audio_obj_source_set(out, "/tmp/file/does/not/exist/hopefully.wav");
 //   fail_if(ret);
 
-   eo_do(out, ret = ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.wav"));
+   ret = ecore_audio_obj_source_set(out, TESTS_BUILD_DIR"/tmp.wav");
    fail_if(!ret);
 
-   eo_do(out, src = ecore_audio_obj_source_get());
+   src = ecore_audio_obj_source_get(out);
    ck_assert_str_eq(src, TESTS_BUILD_DIR"/tmp.wav");
 
-   eo_do(out, ret = ecore_audio_obj_out_input_attach(in));
+   ret = ecore_audio_obj_out_input_attach(out, in);
    fail_if(!ret);
 
-   eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL));
+   eo_event_callback_add(in, ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL);
 
    ecore_main_loop_begin();
 
@@ -330,47 +330,47 @@ START_TEST(ecore_test_ecore_audio_obj_in_out)
   fail_if(!in2);
   fail_if(!out);
 
-  eo_do(in, out2 = ecore_audio_obj_in_output_get());
+  out2 = ecore_audio_obj_in_output_get(in);
 
   fail_if(out2);
 
-  eo_do(out, in3 = ecore_audio_obj_out_inputs_get());
+  in3 = ecore_audio_obj_out_inputs_get(out);
 
   fail_if(eina_list_count(in3) != 0);
 
-  eo_do(out, attached = ecore_audio_obj_out_input_attach(in));
+  attached = ecore_audio_obj_out_input_attach(out, in);
   fail_if(!attached);
 
-  eo_do(out, attached = ecore_audio_obj_out_input_attach(in));
+  attached = ecore_audio_obj_out_input_attach(out, in);
   fail_if(attached);
 
-  eo_do(in, out2 = ecore_audio_obj_in_output_get());
+  out2 = ecore_audio_obj_in_output_get(in);
 
   fail_if(out2 != out);
 
-  eo_do(out, in3 = ecore_audio_obj_out_inputs_get());
+  in3 = ecore_audio_obj_out_inputs_get(out);
 
   fail_if(eina_list_count(in3) != 1);
   fail_if(eina_list_data_get(in3) != in);
 
-  eo_do(out, attached = ecore_audio_obj_out_input_attach(in2));
+  attached = ecore_audio_obj_out_input_attach(out, in2);
   fail_if(!attached);
 
-  eo_do(out, in3 = ecore_audio_obj_out_inputs_get());
+  in3 = ecore_audio_obj_out_inputs_get(out);
 
   fail_if(eina_list_count(in3) != 2);
   fail_if(eina_list_data_get(in3) != in);
 
   eo_del(in2);
 
-  eo_do(out, in3 = ecore_audio_obj_out_inputs_get());
+  in3 = ecore_audio_obj_out_inputs_get(out);
 
   fail_if(eina_list_count(in3) != 1);
   fail_if(eina_list_data_get(in3) != in);
 
   eo_del(out);
 
-  eo_do(in, out2 = ecore_audio_obj_in_output_get());
+  out2 = ecore_audio_obj_in_output_get(in);
 
   fail_if(out2);
 
@@ -426,10 +426,10 @@ START_TEST(ecore_test_ecore_audio_obj_vio)
   out = eo_add(ECORE_AUDIO_OUT_CLASS, NULL);
   fail_if(!out);
 
-  eo_do(in, ecore_audio_obj_vio_set(&in_vio, NULL, NULL));
-  eo_do(out, ecore_audio_obj_vio_set(&out_vio, NULL, NULL));
+  ecore_audio_obj_vio_set(in, &in_vio, NULL, NULL);
+  ecore_audio_obj_vio_set(out, &out_vio, NULL, NULL);
 
-  eo_do(out, ecore_audio_obj_out_input_attach(in));
+  ecore_audio_obj_out_input_attach(out, in);
 
   ecore_main_loop_begin();
 
@@ -462,71 +462,71 @@ START_TEST(ecore_test_ecore_audio_obj_in)
 
   fail_if(!in);
 
-  eo_do(in, ecore_audio_obj_vio_set(&vio, &freed, _myfree));
+  ecore_audio_obj_vio_set(in, &vio, &freed, _myfree);
   fail_if(freed);
 
-  eo_do(in, ecore_audio_obj_vio_set(NULL, NULL, NULL));
+  ecore_audio_obj_vio_set(in, NULL, NULL, NULL);
   fail_if(!freed);
 
-  eo_do(in, speed = ecore_audio_obj_in_speed_get());
+  speed = ecore_audio_obj_in_speed_get(in);
   fail_if(speed != 1.0);
 
-  eo_do(in, ecore_audio_obj_in_speed_set(2.5));
+  ecore_audio_obj_in_speed_set(in, 2.5);
 
-  eo_do(in, speed = ecore_audio_obj_in_speed_get());
+  speed = ecore_audio_obj_in_speed_get(in);
   fail_if(speed != 2.5);
 
-  eo_do(in, ecore_audio_obj_in_speed_set(0));
+  ecore_audio_obj_in_speed_set(in, 0);
 
-  eo_do(in, speed = ecore_audio_obj_in_speed_get());
+  speed = ecore_audio_obj_in_speed_get(in);
   fail_if(speed != 0.2);
 
-  eo_do(in, ecore_audio_obj_in_speed_set(10));
+  ecore_audio_obj_in_speed_set(in, 10);
 
-  eo_do(in, speed = ecore_audio_obj_in_speed_get());
+  speed = ecore_audio_obj_in_speed_get(in);
   fail_if(speed != 5.0);
 
-  eo_do(in, samplerate = ecore_audio_obj_in_samplerate_get());
+  samplerate = ecore_audio_obj_in_samplerate_get(in);
   fail_if(samplerate != 0);
 
-  eo_do(in, ecore_audio_obj_in_samplerate_set(1234));
+  ecore_audio_obj_in_samplerate_set(in, 1234);
 
-  eo_do(in, samplerate = ecore_audio_obj_in_samplerate_get());
+  samplerate = ecore_audio_obj_in_samplerate_get(in);
   fail_if(samplerate != 1234);
 
-  eo_do(in, channels = ecore_audio_obj_in_channels_get());
+  channels = ecore_audio_obj_in_channels_get(in);
   fail_if(channels != 0);
 
-  eo_do(in, ecore_audio_obj_in_channels_set(2));
+  ecore_audio_obj_in_channels_set(in, 2);
 
-  eo_do(in, channels = ecore_audio_obj_in_channels_get());
+  channels = ecore_audio_obj_in_channels_get(in);
   fail_if(channels != 2);
 
-  eo_do(in, looped = ecore_audio_obj_in_looped_get());
+  looped = ecore_audio_obj_in_looped_get(in);
   fail_if(looped);
 
-  eo_do(in, ecore_audio_obj_in_looped_set(EINA_TRUE));
+  ecore_audio_obj_in_looped_set(in, EINA_TRUE);
 
-  eo_do(in, looped = ecore_audio_obj_in_looped_get());
+  looped = ecore_audio_obj_in_looped_get(in);
   fail_if(!looped);
 
-  eo_do(in, length = ecore_audio_obj_in_length_get());
+  length = ecore_audio_obj_in_length_get(in);
   fail_if(length != 0);
 
-  eo_do(in, length = ecore_audio_obj_in_remaining_get());
+  length = ecore_audio_obj_in_remaining_get(in);
   fail_if(length != -1);
 
   memset(buf, 0xaa, 10);
-  eo_do(in, read = ecore_audio_obj_in_read(buf, 10));
+  read = ecore_audio_obj_in_read(in, buf, 10);
   fail_if(read != 0);
 
   for (i=0; i<10; i++) {
       fail_if(buf[i] != 0xaa);
   }
 
-  eo_do(in, ecore_audio_obj_paused_set(EINA_TRUE));
+  ecore_audio_obj_paused_set(in, EINA_TRUE);
 
-  eo_do(in, read = ecore_audio_obj_in_read(buf, 10));
+  read = ecore_audio_obj_in_read(in, buf, 10);
   fail_if(read != 10);
 
   for (i=0; i<10; i++) {
@@ -556,29 +556,29 @@ START_TEST(ecore_test_ecore_audio_obj)
 
     fail_if(!obj);
 
-    eo_do(obj, name = ecore_audio_obj_name_get());
+    name = ecore_audio_obj_name_get(obj);
 
     fail_if(name);
 
-    eo_do(obj, ecore_audio_obj_name_set("In1"));
-    eo_do(obj, name = ecore_audio_obj_name_get());
+    ecore_audio_obj_name_set(obj, "In1");
+    name = ecore_audio_obj_name_get(obj);
 
     ck_assert_str_eq(name, "In1");
 
-    eo_do(obj, ecore_audio_obj_name_get());
+    ecore_audio_obj_name_get(obj);
 
-    eo_do(obj, paused = ecore_audio_obj_paused_get());
+    paused = ecore_audio_obj_paused_get(obj);
     fail_if(paused);
 
-    eo_do(obj, ecore_audio_obj_paused_set(EINA_TRUE));
-    eo_do(obj, paused = ecore_audio_obj_paused_get());
+    ecore_audio_obj_paused_set(obj, EINA_TRUE);
+    paused = ecore_audio_obj_paused_get(obj);
     fail_if(!paused);
 
-    eo_do(obj, volume = ecore_audio_obj_volume_get());
+    volume = ecore_audio_obj_volume_get(obj);
     fail_if(volume != 1.0);
 
-    eo_do(obj, ecore_audio_obj_volume_set(0.5));
-    eo_do(obj, volume = ecore_audio_obj_volume_get());
+    ecore_audio_obj_volume_set(obj, 0.5);
+    volume = ecore_audio_obj_volume_get(obj);
     fail_if(volume != 0.5);
 
     eo_del(obj);
diff --git a/src/tests/edje/edje_test_edje.c b/src/tests/edje/edje_test_edje.c
index b406bad..e28329f 100644
--- a/src/tests/edje/edje_test_edje.c
+++ b/src/tests/edje/edje_test_edje.c
@@ -192,15 +192,15 @@ START_TEST(edje_test_masking)
 
    /* check value of no_render flag as seen from evas land */
    sub = edje_object_part_object_get(obj, "mask");
-   fail_if(!eo_do_ret(sub, b, evas_obj_no_render_get()));
+   fail_if(!evas_obj_no_render_get(sub));
 
    /* check that text has a clip (based on description.clip_to) */
    sub = edje_object_part_object_get(obj, "text");
-   fail_if(!eo_do_ret(sub, clip2, evas_obj_clip_get()));
+   fail_if(!evas_obj_clip_get(sub));
 
    /* test description.clip_to override */
    sub = edje_object_part_object_get(obj, "noclip");
-   clip2 = eo_do_ret(sub, clip2, evas_obj_clip_get());
+   clip2 = evas_obj_clip_get(sub);
    fail_if(clip != clip2);
 
    EDJE_TEST_FREE_EVAS();
@@ -224,23 +224,23 @@ START_TEST(edje_test_filters)
 
    /* check value of no_render flag as seen from evas land */
    sub = edje_object_part_object_get(obj, "mask");
-   fail_if(!eo_do_ret(sub, b, evas_obj_no_render_get()));
+   fail_if(!evas_obj_no_render_get(sub));
 
    /* check no_render inheritance */
    sub = edje_object_part_object_get(obj, "mask2");
-   fail_if(eo_do_ret(sub, b, evas_obj_no_render_get()));
+   fail_if(evas_obj_no_render_get(sub));
    sub = edje_object_part_object_get(obj, "mask3");
-   fail_if(!eo_do_ret(sub, b, evas_obj_no_render_get()));
+   fail_if(!evas_obj_no_render_get(sub));
 
    /* text part: check filter status */
    text = edje_object_part_object_get(obj, "text");
    fail_if(!text);
 
-   eo_do(text, efl_gfx_filter_program_get(&prg, &name));
+   efl_gfx_filter_program_get(text, &prg, &name);
    fail_if(!prg);
    fail_if(!name || strcmp(name, "filterfile"));
 
-   eo_do(text, src = efl_gfx_filter_source_get("mask"));
+   src = efl_gfx_filter_source_get(text, "mask");
    fail_if(!src);
 
    // TODO: Verify properly that the filter runs well
@@ -265,7 +265,7 @@ START_TEST(edje_test_snapshot)
 
    /* check value of no_render flag as seen from evas land */
    sub = edje_object_part_object_get(obj, "snap");
-   fail_if(!eo_do_ret(sub, b, evas_obj_image_snapshot_get()));
+   fail_if(!evas_obj_image_snapshot_get(sub));
 
    // TODO: Verify that evas snapshot actually works (and has a filter)
 
diff --git a/src/tests/eina_cxx/simple.c b/src/tests/eina_cxx/simple.c
index 8a742e1..a40eb27 100644
--- a/src/tests/eina_cxx/simple.c
+++ b/src/tests/eina_cxx/simple.c
@@ -14,7 +14,7 @@
 
 static Eo *_simple_eo_base_constructor(Eo *obj, void *pd EINA_UNUSED)
 {
-   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   return eo_constructor(eo_super(obj, MY_CLASS));
 }
 
 #include "simple.eo.c"
diff --git a/src/tests/eio/eio_model_test_file.c b/src/tests/eio/eio_model_test_file.c
index 56e6dd6..5873d7a 100644
--- a/src/tests/eio/eio_model_test_file.c
+++ b/src/tests/eio/eio_model_test_file.c
@@ -84,26 +84,26 @@ _load_status_cb(void *data EINA_UNUSED, const Eo_Event *event)
         char *str;
 
         printf("Model is Loaded\n");
-        eo_do(event->obj, status = efl_model_property_get("filename", &value_prop));
+        status = efl_model_property_get(event->obj, "filename", &value_prop);
         str = eina_value_to_string(value_prop);
         printf("efl_model_loaded filename %s, status=%d\n", str, status);
         free(str);
 
-        eo_do(event->obj, status = efl_model_property_get("size", &value_prop));
+        status = efl_model_property_get(event->obj, "size", &value_prop);
         str = eina_value_to_string(value_prop);
         printf("efl_model_loaded size %s, status=%d\n", str, status);
         free(str);
 
-        eo_do(event->obj, status = efl_model_property_get("mtime", &value_prop));
+        status = efl_model_property_get(event->obj, "mtime", &value_prop);
         str = eina_value_to_string(value_prop);
         printf("efl_model_loaded mtime %s, status=%d\n", str, status);
         free(str);
 
-        eo_do(event->obj, efl_model_children_count_get(&total));
+        efl_model_children_count_get(event->obj, &total);
         printf("efl_model_test count %d\n", (int)total);
 
         /**< get full list */
-        eo_do(event->obj, status = efl_model_children_slice_get(0 ,0 ,(Eina_Accessor **)&accessor));
+        status = efl_model_children_slice_get(event->obj, 0, 0, (Eina_Accessor **)&accessor);
         eina_accessor_free(accessor);
         ecore_main_loop_quit();
      }
@@ -143,7 +143,7 @@ _children_count_cb(void *data EINA_UNUSED, const Eo_Event *event)
    fprintf(stdout, "Children count number=%d\n", *len);
    reqs.children = *len;
 
-   eo_do(event->obj, efl_model_children_count_get(&total));
+   efl_model_children_count_get(event->obj, &total);
    fprintf(stdout, "New total children count number=%d\n", *len);
 
    return EINA_TRUE;
@@ -165,27 +165,27 @@ START_TEST(eio_model_test_test_file)
    fail_if(!ecore_init(), "ERROR: Cannot init Ecore!\n");
    fail_if(!eio_init(), "ERROR: Cannot init EIO!\n");
 
-   filemodel = eo_add(EIO_MODEL_CLASS, NULL, eio_model_path_set(EFL_MODEL_TEST_FILENAME_PATH));
+   filemodel = eo_add(EIO_MODEL_CLASS, NULL, eio_model_path_set(eoid, EFL_MODEL_TEST_FILENAME_PATH));
    fail_if(!filemodel, "ERROR: Cannot init model!\n");
 
-   eo_do(filemodel, eo_event_callback_add(EFL_MODEL_BASE_EVENT_LOAD_STATUS, _load_status_cb, NULL));
-   eo_do(filemodel, eo_event_callback_add(EFL_MODEL_BASE_EVENT_PROPERTIES_CHANGED, _properties_change_cb, NULL));
-   eo_do(filemodel, eo_event_callback_add(EFL_MODEL_BASE_EVENT_CHILDREN_COUNT_CHANGED, _children_count_cb, NULL));
+   eo_event_callback_add(filemodel, EFL_MODEL_BASE_EVENT_LOAD_STATUS, _load_status_cb, NULL);
+   eo_event_callback_add(filemodel, EFL_MODEL_BASE_EVENT_PROPERTIES_CHANGED, _properties_change_cb, NULL);
+   eo_event_callback_add(filemodel, EFL_MODEL_BASE_EVENT_CHILDREN_COUNT_CHANGED, _children_count_cb, NULL);
 
-   eo_do(filemodel, efl_model_load());
+   efl_model_load(filemodel);
 
    handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);
 
    ecore_main_loop_begin();
 
-   eo_do(filemodel, status = efl_model_property_get("filename", &value_prop));
+   status = efl_model_property_get(filemodel, "filename", &value_prop);
    str = eina_value_to_string(value_prop);
    printf("efl_model_test filename %s, load status %d\n", str, status);
 
    free(str);
 
    i = 0;
-   eo_do(filemodel, efl_model_properties_get(&properties_list));
+   efl_model_properties_get(filemodel, &properties_list);
    EINA_ARRAY_ITER_NEXT(properties_list, i, str, iterator)
      {
         fprintf(stdout, "Returned property list %d: %s\n", i, str);
diff --git a/src/tests/eio/eio_model_test_monitor_add.c b/src/tests/eio/eio_model_test_monitor_add.c
index 4f26a8e..b718edd 100644
--- a/src/tests/eio/eio_model_test_monitor_add.c
+++ b/src/tests/eio/eio_model_test_monitor_add.c
@@ -29,7 +29,7 @@ _load_monitor_status_cb(void *data, const Eo_Event *event)
   if (!(st->status & EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES))
     return EINA_TRUE;
 
-  eo_do(event->obj, efl_model_property_get("path", &value_prop));
+  efl_model_property_get(event->obj, "path", &value_prop);
   fail_if(!value_prop, "ERROR: Cannot get property!\n");
 
   str = eina_value_to_string(value_prop);
@@ -38,9 +38,9 @@ _load_monitor_status_cb(void *data, const Eo_Event *event)
   if(temp_filename && strcmp(str, temp_filename) == 0)
     {
       fprintf(stderr, "is child that we want\n");
-      eo_do(event->obj, eo_event_callback_del(EFL_MODEL_BASE_EVENT_LOAD_STATUS, _load_monitor_status_cb, data));
+      eo_event_callback_del(event->obj, EFL_MODEL_BASE_EVENT_LOAD_STATUS, _load_monitor_status_cb, data);
       children_added = EINA_TRUE;
-      eo_do(parent, efl_model_child_del(event->obj));
+      efl_model_child_del(parent, event->obj);
     }
 
     return EINA_FALSE;
@@ -54,13 +54,13 @@ _children_removed_cb(void *data EINA_UNUSED, const Eo_Event *event)
        Efl_Model_Children_Event* evt = event->event_info;
 
        Eina_Bool b;
-       eo_do(evt->child, b = efl_model_load_status_get() & EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
+       b = efl_model_load_status_get(evt->child);
        if(b)
          {
             const Eina_Value* value_prop = NULL;
             const char* str = NULL;
 
-            eo_do(evt->child, efl_model_property_get("path", &value_prop));
+            efl_model_property_get(evt->child, "path", &value_prop);
             fail_if(!value_prop, "ERROR: Cannot get property!\n");
 
             str = eina_value_to_string(value_prop);
@@ -79,8 +79,8 @@ _children_added_cb(void *data EINA_UNUSED, const Eo_Event *event)
   if (evt == NULL)
     return EINA_TRUE;
 
-  eo_do(evt->child, eo_event_callback_add(EFL_MODEL_BASE_EVENT_LOAD_STATUS, _load_monitor_status_cb, event->obj));
-  eo_do(evt->child, efl_model_load());
+  eo_event_callback_add(evt->child, EFL_MODEL_BASE_EVENT_LOAD_STATUS, _load_monitor_status_cb, event->obj);
+  efl_model_load(evt->child);
 
   return EINA_TRUE;
 }
@@ -98,7 +98,7 @@ _children_count_cb(void *data EINA_UNUSED, const Eo_Event *event)
    fprintf(stderr, "Children count number=%d\n", *len);
 
    /**< get full list */
-   eo_do(event->obj, status = efl_model_children_slice_get(0 ,0 ,(Eina_Accessor **)&accessor));
+   status = efl_model_children_slice_get(event->obj, 0, 0, (Eina_Accessor **)&accessor);
    if(accessor != NULL)
      {
         EINA_ACCESSOR_FOREACH(accessor, i, child) {}
@@ -125,14 +125,14 @@ START_TEST(eio_model_test_test_monitor_add)
 
    tmpdir = eina_environment_tmp_get();
 
-   filemodel = eo_add(EIO_MODEL_CLASS, NULL, eio_model_path_set(tmpdir));
+   filemodel = eo_add(EIO_MODEL_CLASS, NULL, eio_model_path_set(eoid, tmpdir));
    fail_if(!filemodel, "ERROR: Cannot init model!\n");
 
-   eo_do(filemodel, eo_event_callback_add(EFL_MODEL_BASE_EVENT_CHILD_ADDED, _children_added_cb, NULL));
-   eo_do(filemodel, eo_event_callback_add(EFL_MODEL_BASE_EVENT_CHILD_REMOVED, _children_removed_cb, NULL));
-   eo_do(filemodel, eo_event_callback_add(EFL_MODEL_BASE_EVENT_CHILDREN_COUNT_CHANGED, _children_count_cb, NULL));
+   eo_event_callback_add(filemodel, EFL_MODEL_BASE_EVENT_CHILD_ADDED, _children_added_cb, NULL);
+   eo_event_callback_add(filemodel, EFL_MODEL_BASE_EVENT_CHILD_REMOVED, _children_removed_cb, NULL);
+   eo_event_callback_add(filemodel, EFL_MODEL_BASE_EVENT_CHILDREN_COUNT_CHANGED, _children_count_cb, NULL);
 
-   eo_do(filemodel, efl_model_load());
+   efl_model_load(filemodel);
 
    ecore_main_loop_begin();
 
diff --git a/src/tests/eldbus/eldbus_test_eldbus_model.c b/src/tests/eldbus/eldbus_test_eldbus_model.c
index adba9f5..5439217 100644
--- a/src/tests/eldbus/eldbus_test_eldbus_model.c
+++ b/src/tests/eldbus/eldbus_test_eldbus_model.c
@@ -24,9 +24,9 @@ _eo_event_quit_cb(void *data EINA_UNUSED, const Eo_Event *event EINA_UNUSED)
 void
 efl_model_wait_for_event(Eo *obj, const Eo_Event_Description* event)
 {
-   eo_do(obj, eo_event_callback_add(event, _eo_event_quit_cb, NULL));
+   eo_event_callback_add(obj, event, _eo_event_quit_cb, NULL);
    ecore_main_loop_begin();
-   eo_do(obj, eo_event_callback_del(event, _eo_event_quit_cb, NULL));
+   eo_event_callback_del(obj, event, _eo_event_quit_cb, NULL);
 }
 
 static Eina_Bool
@@ -49,13 +49,13 @@ void
 efl_model_wait_for_load_status(Efl_Model_Base *efl_model, Efl_Model_Load_Status expected_status)
 {
    Efl_Model_Load_Status actual_status;
-   eo_do(efl_model, actual_status = efl_model_load_status_get());
+   actual_status = efl_model_load_status_get(efl_model);
    if (expected_status == actual_status)
      return;
 
-   eo_do(efl_model, eo_event_callback_add(EFL_MODEL_BASE_EVENT_LOAD_STATUS, _event_load_status_quit_cb, (void*)expected_status));
+   eo_event_callback_add(efl_model, EFL_MODEL_BASE_EVENT_LOAD_STATUS, _event_load_status_quit_cb, (void*)expected_status);
    ecore_main_loop_begin();
-   eo_do(efl_model, eo_event_callback_del(EFL_MODEL_BASE_EVENT_LOAD_STATUS, _event_load_status_quit_cb, (void*)expected_status));
+   eo_event_callback_del(efl_model, EFL_MODEL_BASE_EVENT_LOAD_STATUS, _event_load_status_quit_cb, (void*)expected_status);
 }
 
 Efl_Model_Base *
@@ -63,7 +63,7 @@ efl_model_nth_child_get(Efl_Model_Base *efl_model, unsigned int n)
 {
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(efl_model, status = efl_model_children_slice_get(n, 1, &accessor));
+   status = efl_model_children_slice_get(efl_model, n, 1, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, accessor);
    Eo *child = NULL;
@@ -83,7 +83,7 @@ efl_model_first_child_get(Efl_Model_Base *efl_model)
 void
 efl_model_load_and_wait_for_load_status(Eo *obj, Efl_Model_Load_Status expected_status)
 {
-   eo_do(obj, efl_model_load());
+   efl_model_load(obj);
    efl_model_wait_for_load_status(obj, expected_status);
 }
 
@@ -106,7 +106,7 @@ check_property(Eo *object, const char *property_name, const char *expected_value
 {
    Eina_Value const* property_value;
    Efl_Model_Load_Status status;
-   eo_do(object, status = efl_model_property_get(property_name, &property_value));
+   status = efl_model_property_get(object, property_name, &property_value);
    ck_assert_msg(EFL_MODEL_LOAD_STATUS_ERROR != status, "Nonexistent property: %s", property_name);
    ck_assert_ptr_ne(NULL, property_value);
    char *actual_value = eina_value_to_string(property_value);
@@ -123,10 +123,7 @@ check_property(Eo *object, const char *property_name, const char *expected_value
 Eo *
 create_connection(void)
 {
-   Eo *connection = eo_add_ref(ELDBUS_MODEL_CONNECTION_CLASS, NULL,
-     eldbus_model_connection_constructor(ELDBUS_CONNECTION_TYPE_SESSION,
-                                         NULL,
-                                         EINA_FALSE));
+   Eo *connection = eo_add_ref(ELDBUS_MODEL_CONNECTION_CLASS, NULL, eldbus_model_connection_constructor(eoid, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE));
    ck_assert_ptr_ne(NULL, connection);
    return connection;
 }
@@ -142,12 +139,7 @@ create_and_load_connection(void)
 Eo *
 create_object(void)
 {
-   Eo *object = eo_add_ref(ELDBUS_MODEL_OBJECT_CLASS, NULL,
-     eldbus_model_object_constructor(ELDBUS_CONNECTION_TYPE_SESSION,
-                                     NULL,
-                                     EINA_FALSE,
-                                     ELDBUS_FDO_BUS,
-                                     ELDBUS_FDO_PATH));
+   Eo *object = eo_add_ref(ELDBUS_MODEL_OBJECT_CLASS, NULL, eldbus_model_object_constructor(eoid, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, ELDBUS_FDO_BUS, ELDBUS_FDO_PATH));
    ck_assert_ptr_ne(NULL, object);
    return object;
 }
@@ -164,7 +156,7 @@ void
 check_efl_model_load_status_get(Efl_Model_Base *efl_model, Efl_Model_Load_Status expected_load_status)
 {
    Efl_Model_Load_Status actual_load_status;
-   eo_do(efl_model, actual_load_status = efl_model_load_status_get());
+   actual_load_status = efl_model_load_status_get(efl_model);
    ck_assert_int_eq(expected_load_status, actual_load_status);
 }
 
@@ -172,7 +164,7 @@ void
 check_efl_model_children_count_eq(Efl_Model_Base *efl_model, unsigned int expected_children_count)
 {
    unsigned int actual_children_count = 0;
-   eo_do(efl_model, efl_model_children_count_get(&actual_children_count));
+   efl_model_children_count_get(efl_model, &actual_children_count);
    ck_assert_int_eq(expected_children_count, actual_children_count);
 }
 
@@ -181,7 +173,7 @@ check_efl_model_children_count_ge(Efl_Model_Base *efl_model, unsigned int minimu
 {
    unsigned int actual_children_count = 0;
    Efl_Model_Load_Status status;
-   eo_do(efl_model, status = efl_model_children_count_get(&actual_children_count));
+   status = efl_model_children_count_get(efl_model, &actual_children_count);
    // A minimum count only exists if model have EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN
    ck_assert((EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN & status) == EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
 
@@ -193,13 +185,13 @@ check_efl_model_children_slice_get(Efl_Model_Base *efl_model)
 {
    unsigned int count = 0;
    Efl_Model_Load_Status status;
-   eo_do(efl_model, status = efl_model_children_count_get(&count));
+   status = efl_model_children_count_get(efl_model, &count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_msg(count, "There must be at least 1 child to test");
 
    // Test slice all
    Eina_Accessor *accessor;
-   eo_do(efl_model, status = efl_model_children_slice_get(0, 0, &accessor));
+   status = efl_model_children_slice_get(efl_model, 0, 0, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, accessor);
    // Get first child
@@ -221,7 +213,7 @@ check_efl_model_children_slice_get(Efl_Model_Base *efl_model)
 
    // Test slice first child
    Eo *child = NULL;
-   eo_do(efl_model, status = efl_model_children_slice_get(1, 1, &accessor));
+   status = efl_model_children_slice_get(efl_model, 1, 1, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, accessor);
    ret = eina_accessor_data_get(accessor, 0, (void**)&child);
@@ -233,7 +225,7 @@ check_efl_model_children_slice_get(Efl_Model_Base *efl_model)
    eina_accessor_free(accessor);
 
    // Test slice last child
-   eo_do(efl_model, status = efl_model_children_slice_get(count, 1, &accessor));
+   status = efl_model_children_slice_get(efl_model, count, 1, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, accessor);
    ret = eina_accessor_data_get(accessor, 0, (void**)&child);
@@ -245,7 +237,7 @@ check_efl_model_children_slice_get(Efl_Model_Base *efl_model)
    eina_accessor_free(accessor);
 
    // Test slice nonexistent element
-   eo_do(efl_model, status = efl_model_children_slice_get(count + 1, 1, &accessor));
+   status = efl_model_children_slice_get(efl_model, count + 1, 1, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_eq(NULL, accessor);
 }
@@ -284,7 +276,7 @@ START_TEST(proxy)
    efl_model_load_and_wait_for_load_status(root, EFL_MODEL_LOAD_STATUS_LOADED);
 
    Eina_Accessor *accessor = NULL;
-   eo_do(root, efl_model_children_slice_get(0, 0, &accessor));
+   efl_model_children_slice_get(root, 0, 0, &accessor);
    ck_assert_ptr_ne(NULL, accessor);
 
    unsigned int i;
@@ -314,7 +306,7 @@ eldbus_model_proxy_from_object_get(Eldbus_Model_Object *object, const char *inte
 {
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(object, status = efl_model_children_slice_get(0, 0, &accessor));
+   status = efl_model_children_slice_get(object, 0, 0, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, accessor);
 
@@ -323,7 +315,7 @@ eldbus_model_proxy_from_object_get(Eldbus_Model_Object *object, const char *inte
    EINA_ACCESSOR_FOREACH(accessor, i, proxy)
      {
         const char *name;
-        eo_do(proxy, name = eldbus_model_proxy_name_get());
+        name = eldbus_model_proxy_name_get(proxy);
         ck_assert_ptr_ne(NULL, name);
         if (strcmp(name, interface_name) == 0)
           goto end;
@@ -340,7 +332,7 @@ _eldbus_model_arguments_from_proxy_get(Eldbus_Model_Proxy *proxy, const char *me
 {
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(proxy, status = efl_model_children_slice_get(0, 0, &accessor));
+   status = efl_model_children_slice_get(proxy, 0, 0, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, accessor);
 
@@ -352,7 +344,7 @@ _eldbus_model_arguments_from_proxy_get(Eldbus_Model_Proxy *proxy, const char *me
           continue;
 
         const char *name;
-        eo_do(child, name = eldbus_model_arguments_name_get());
+        name = eldbus_model_arguments_name_get(child);
         ck_assert_ptr_ne(NULL, name);
         if (strcmp(name, method_name) == 0)
           goto end;
@@ -381,7 +373,7 @@ check_efl_model_property_int_eq(Efl_Model_Base *efl_model, const char *property,
 {
    Eina_Value const* property_value;
    Efl_Model_Load_Status status;
-   eo_do(efl_model, status = efl_model_property_get(property, &property_value));
+   status = efl_model_property_get(efl_model, property, &property_value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, property_value);
 
@@ -400,7 +392,7 @@ check_efl_model_property_int_set(Efl_Model_Base *efl_model, const char *property
    eina_value_setup(&eina_value, EINA_VALUE_TYPE_INT);
    eina_value_set(&eina_value, value);
    Efl_Model_Load_Status status;
-   eo_do(efl_model, status = efl_model_property_set(property, &eina_value));
+   status = efl_model_property_set(efl_model, property, &eina_value);
    eina_value_flush(&eina_value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 }
diff --git a/src/tests/eldbus/eldbus_test_eldbus_model_connection.c b/src/tests/eldbus/eldbus_test_eldbus_model_connection.c
index ffcc795..f3b1915 100644
--- a/src/tests/eldbus/eldbus_test_eldbus_model_connection.c
+++ b/src/tests/eldbus/eldbus_test_eldbus_model_connection.c
@@ -43,7 +43,7 @@ START_TEST(properties_get)
 {
    Eina_Array *properties = NULL;
    Efl_Model_Load_Status status;
-   eo_do(connection, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(connection, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, properties);
 
@@ -52,7 +52,7 @@ START_TEST(properties_get)
    ck_assert_int_eq(expected_properties_count, actual_properties_count);
 
    // Unloaded connection populates its properties
-   eo_do(unloaded_connection, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(unloaded_connection, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_UNLOADED, status);
    ck_assert_ptr_ne(NULL, properties);
 
@@ -65,12 +65,12 @@ START_TEST(property_get)
 {
    Eina_Value const* property_value;
    Efl_Model_Load_Status status;
-   eo_do(connection, status = efl_model_property_get(UNIQUE_NAME_PROPERTY, &property_value));
+   status = efl_model_property_get(connection, UNIQUE_NAME_PROPERTY, &property_value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, property_value);
 
    // Nonexistent property must return EFL_MODEL_LOAD_STATUS_ERROR
-   eo_do(connection, status = efl_model_property_get("nonexistent", &property_value));
+   status = efl_model_property_get(connection, "nonexistent", &property_value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -82,19 +82,19 @@ START_TEST(property_set)
    eina_value_setup(&value, EINA_VALUE_TYPE_INT);
    eina_value_set(&value, 1);
    Efl_Model_Load_Status status;
-   eo_do(connection, status = efl_model_property_set("nonexistent", &value));
+   status = efl_model_property_set(connection, "nonexistent", &value);
    eina_value_flush(&value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    // UNIQUE_NAME_PROPERTY is read-only
-   eo_do(connection, status = efl_model_property_set(UNIQUE_NAME_PROPERTY, &value));
+   status = efl_model_property_set(connection, UNIQUE_NAME_PROPERTY, &value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    // The model must be loaded to be able to set its properties
    const char *expected_value = "unloaded";
    eina_value_setup(&value, EINA_VALUE_TYPE_STRING);
    eina_value_set(&value, expected_value);
-   eo_do(unloaded_connection, status = efl_model_property_set(UNIQUE_NAME_PROPERTY, &value));
+   status = efl_model_property_set(unloaded_connection, UNIQUE_NAME_PROPERTY, &value);
    eina_value_flush(&value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
@@ -120,7 +120,7 @@ START_TEST(children_slice_get)
    // Unloaded connection must return EFL_MODEL_LOAD_STATUS_UNLOADED
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(unloaded_connection, status = efl_model_children_slice_get(0, 0, &accessor));
+   status = efl_model_children_slice_get(unloaded_connection, 0, 0, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_UNLOADED, status);
    ck_assert_ptr_eq(NULL, accessor);
 }
@@ -129,7 +129,7 @@ END_TEST
 START_TEST(unload)
 {
    check_efl_model_load_status_get(connection, EFL_MODEL_LOAD_STATUS_LOADED);
-   eo_do(connection, efl_model_unload());
+   efl_model_unload(connection);
    check_efl_model_load_status_get(connection, EFL_MODEL_LOAD_STATUS_UNLOADED);
 
    check_efl_model_children_count_eq(connection, 0);
@@ -138,14 +138,14 @@ END_TEST
 
 START_TEST(properties_load)
 {
-   eo_do(unloaded_connection, efl_model_properties_load());
+   efl_model_properties_load(unloaded_connection);
    check_efl_model_load_status_get(unloaded_connection, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
 }
 END_TEST
 
 START_TEST(children_load)
 {
-   eo_do(unloaded_connection, efl_model_children_load());
+   efl_model_children_load(unloaded_connection);
 
    check_efl_model_load_status_get(unloaded_connection, EFL_MODEL_LOAD_STATUS_LOADING_CHILDREN);
 
@@ -160,7 +160,7 @@ END_TEST
 START_TEST(child_add)
 {
    Eo *child;
-   eo_do(connection, child = efl_model_child_add());
+   child = efl_model_child_add(connection);
    ck_assert_ptr_eq(NULL, child);
 }
 END_TEST
@@ -169,15 +169,15 @@ START_TEST(child_del)
 {
    unsigned int expected_children_count = 0;
    Efl_Model_Load_Status status;
-   eo_do(connection, status = efl_model_children_count_get(&expected_children_count));
+   status = efl_model_children_count_get(connection, &expected_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    Eo *child = efl_model_first_child_get(connection);
-   eo_do(connection, status = efl_model_child_del(child));
+   status = efl_model_child_del(connection, child);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    unsigned int actual_children_count = 0;
-   eo_do(connection, status = efl_model_children_count_get(&actual_children_count));
+   status = efl_model_children_count_get(connection, &actual_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    ck_assert_int_le(expected_children_count, actual_children_count);
diff --git a/src/tests/eldbus/eldbus_test_eldbus_model_method.c b/src/tests/eldbus/eldbus_test_eldbus_model_method.c
index e4f7a81..51ed4af 100644
--- a/src/tests/eldbus/eldbus_test_eldbus_model_method.c
+++ b/src/tests/eldbus/eldbus_test_eldbus_model_method.c
@@ -29,12 +29,7 @@ _setup(void)
 
    fake_server = fake_server_start(&fake_server_data);
 
-   fake_server_object = eo_add(ELDBUS_MODEL_OBJECT_CLASS, NULL,
-     eldbus_model_object_constructor(ELDBUS_CONNECTION_TYPE_SESSION,
-                                     NULL,
-                                     EINA_FALSE,
-                                     FAKE_SERVER_BUS,
-                                     FAKE_SERVER_PATH));
+   fake_server_object = eo_add(ELDBUS_MODEL_OBJECT_CLASS, NULL, eldbus_model_object_constructor(eoid, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
    ck_assert_ptr_ne(NULL, fake_server_object);
 
    efl_model_load_and_wait_for_load_status(fake_server_object, EFL_MODEL_LOAD_STATUS_LOADED);
@@ -70,7 +65,7 @@ START_TEST(properties_get)
 {
    Eina_Array *properties = NULL;
    Efl_Model_Load_Status status;
-   eo_do(method, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(method, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, properties);
 
@@ -85,14 +80,14 @@ START_TEST(property_get)
    // Input only property returns error
    Eina_Value const* dummy;
    Efl_Model_Load_Status status;
-   eo_do(method, status = efl_model_property_get(ARGUMENT_A, &dummy));
+   status = efl_model_property_get(method, ARGUMENT_A, &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
-   eo_do(method, status = efl_model_property_get(ARGUMENT_RESULT, &dummy));
+   status = efl_model_property_get(method, ARGUMENT_RESULT, &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    // Nonexistent property returns error
-   eo_do(method, status = efl_model_property_get("nonexistent", &dummy));
+   status = efl_model_property_get(method, "nonexistent", &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -102,7 +97,7 @@ START_TEST(property_set)
    // Output argument returns error
    Eina_Value dummy = {0};
    Efl_Model_Load_Status status;
-   eo_do(method, status = efl_model_property_set(ARGUMENT_RESULT, &dummy));
+   status = efl_model_property_set(method, ARGUMENT_RESULT, &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -123,7 +118,7 @@ START_TEST(children_slice_get)
 {
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(method, status = efl_model_children_slice_get(1, 1, &accessor));
+   status = efl_model_children_slice_get(method, 1, 1, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_eq(NULL, accessor);
 }
@@ -133,7 +128,7 @@ static void
 _check_unload(void)
 {
    check_efl_model_load_status_get(method, EFL_MODEL_LOAD_STATUS_LOADED);
-   eo_do(method, efl_model_unload());
+   efl_model_unload(method);
    check_efl_model_load_status_get(method, EFL_MODEL_LOAD_STATUS_UNLOADED);
 
    check_efl_model_children_count_eq(method, 0);
@@ -149,7 +144,7 @@ START_TEST(properties_load)
 {
    _check_unload();
 
-   eo_do(method, efl_model_properties_load());
+   efl_model_properties_load(method);
    efl_model_wait_for_load_status(method, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
 
    check_efl_model_load_status_get(method, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
@@ -160,7 +155,7 @@ START_TEST(children_load)
 {
    _check_unload();
 
-   eo_do(method, efl_model_children_load());
+   efl_model_children_load(method);
    efl_model_wait_for_load_status(method, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
 
    check_efl_model_load_status_get(method, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
@@ -172,7 +167,7 @@ END_TEST
 START_TEST(child_add)
 {
    Eo *child;
-   eo_do(method, child = efl_model_child_add());
+   child = efl_model_child_add(method);
    ck_assert_ptr_eq(NULL, child);
 }
 END_TEST
@@ -182,7 +177,7 @@ START_TEST(child_del)
    // efl_model_child_del always returns ERROR
    Eo *child = NULL;
    Efl_Model_Load_Status status;
-   eo_do(method, status = efl_model_child_del(child));
+   status = efl_model_child_del(method, child);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -193,7 +188,7 @@ START_TEST(call)
    check_efl_model_property_int_set(method, ARGUMENT_B, 87654321);
 
    Efl_Model_Load_Status status;
-   eo_do(method, status = eldbus_model_method_call());
+   status = eldbus_model_method_call(method);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    efl_model_wait_for_event(method, ELDBUS_MODEL_METHOD_EVENT_SUCCESSFUL_CALL);
diff --git a/src/tests/eldbus/eldbus_test_eldbus_model_object.c b/src/tests/eldbus/eldbus_test_eldbus_model_object.c
index c1f1248..faa64a7 100644
--- a/src/tests/eldbus/eldbus_test_eldbus_model_object.c
+++ b/src/tests/eldbus/eldbus_test_eldbus_model_object.c
@@ -43,7 +43,7 @@ START_TEST(properties_get)
 {
    Eina_Array *properties = NULL;
    Efl_Model_Load_Status status;
-   eo_do(object, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(object, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, properties);
 
@@ -52,7 +52,7 @@ START_TEST(properties_get)
    ck_assert_int_eq(expected_properties_count, actual_properties_count);
 
    // Unloaded object populates its properties
-   eo_do(unloaded_object, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(unloaded_object, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_UNLOADED, status);
    ck_assert_ptr_ne(NULL, properties);
 
@@ -65,11 +65,11 @@ START_TEST(property_get)
 {
    const Eina_Value* property_value;
    Efl_Model_Load_Status status;
-   eo_do(object, status = efl_model_property_get(UNIQUE_NAME_PROPERTY, &property_value));
+   status = efl_model_property_get(object, UNIQUE_NAME_PROPERTY, &property_value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    // Nonexistent property must return EFL_MODEL_LOAD_STATUS_ERROR
-   eo_do(object, status = efl_model_property_get("nonexistent", &property_value));
+   status = efl_model_property_get(object, "nonexistent", &property_value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -81,19 +81,19 @@ START_TEST(property_set)
    eina_value_setup(&value, EINA_VALUE_TYPE_INT);
    eina_value_set(&value, 1);
    Efl_Model_Load_Status status;
-   eo_do(object, status = efl_model_property_set("nonexistent", &value));
+   status = efl_model_property_set(object, "nonexistent", &value);
    eina_value_flush(&value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    // UNIQUE_NAME_PROPERTY is read-only
-   eo_do(object, status = efl_model_property_set(UNIQUE_NAME_PROPERTY, &value));
+   status = efl_model_property_set(object, UNIQUE_NAME_PROPERTY, &value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    // The model must be loaded to be able to set its properties
    const char *expected_value = "unloaded";
    eina_value_setup(&value, EINA_VALUE_TYPE_STRING);
    eina_value_set(&value, expected_value);
-   eo_do(unloaded_object, status = efl_model_property_set(UNIQUE_NAME_PROPERTY, &value));
+   status = efl_model_property_set(unloaded_object, UNIQUE_NAME_PROPERTY, &value);
    eina_value_flush(&value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
@@ -119,7 +119,7 @@ START_TEST(children_slice_get)
    // Unloaded object must return EFL_MODEL_LOAD_STATUS_UNLOADED
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(unloaded_object, status = efl_model_children_slice_get(0, 0, &accessor));
+   status = efl_model_children_slice_get(unloaded_object, 0, 0, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_UNLOADED, status);
    ck_assert_ptr_eq(NULL, accessor);
 }
@@ -128,7 +128,7 @@ END_TEST
 START_TEST(unload)
 {
    check_efl_model_load_status_get(object, EFL_MODEL_LOAD_STATUS_LOADED);
-   eo_do(object, efl_model_unload());
+   efl_model_unload(object);
    check_efl_model_load_status_get(object, EFL_MODEL_LOAD_STATUS_UNLOADED);
 
    check_efl_model_children_count_eq(object, 0);
@@ -137,14 +137,14 @@ END_TEST
 
 START_TEST(properties_load)
 {
-   eo_do(unloaded_object, efl_model_properties_load());
+   efl_model_properties_load(unloaded_object);
    check_efl_model_load_status_get(unloaded_object, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
 }
 END_TEST
 
 START_TEST(children_load)
 {
-   eo_do(unloaded_object, efl_model_children_load());
+   efl_model_children_load(unloaded_object);
 
    check_efl_model_load_status_get(unloaded_object, EFL_MODEL_LOAD_STATUS_LOADING_CHILDREN);
 
@@ -159,7 +159,7 @@ END_TEST
 START_TEST(child_add)
 {
    Eo *child;
-   eo_do(object, child = efl_model_child_add());
+   child = efl_model_child_add(object);
    ck_assert_ptr_eq(NULL, child);
 }
 END_TEST
@@ -168,15 +168,15 @@ START_TEST(child_del)
 {
    unsigned int expected_children_count = 0;
    Efl_Model_Load_Status status;
-   eo_do(object, status = efl_model_children_count_get(&expected_children_count));
+   status = efl_model_children_count_get(object, &expected_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    Eo *child = efl_model_first_child_get(object);
-   eo_do(object, status = efl_model_child_del(child));
+   status = efl_model_child_del(object, child);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    unsigned int actual_children_count = 0;
-   eo_do(object, status = efl_model_children_count_get(&actual_children_count));
+   status = efl_model_children_count_get(object, &actual_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    ck_assert_int_le(expected_children_count, actual_children_count);
diff --git a/src/tests/eldbus/eldbus_test_eldbus_model_proxy.c b/src/tests/eldbus/eldbus_test_eldbus_model_proxy.c
index 98ce124..741ee95b 100644
--- a/src/tests/eldbus/eldbus_test_eldbus_model_proxy.c
+++ b/src/tests/eldbus/eldbus_test_eldbus_model_proxy.c
@@ -51,13 +51,13 @@ START_TEST(properties_get)
    // ELDBUS_FDO_INTERFACE have no properties
    Eina_Array *properties = NULL;
    Efl_Model_Load_Status status;
-   eo_do(dbus_proxy, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(dbus_proxy, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, properties);
    ck_assert_int_eq(0, eina_array_count(properties));
 
    // Must be loaded to get the properties
-   eo_do(unloaded_dbus_proxy, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(unloaded_dbus_proxy, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -67,7 +67,7 @@ START_TEST(property_get)
    // Nonexistent property must return EFL_MODEL_LOAD_STATUS_ERROR
    const Eina_Value* property_value;
    Efl_Model_Load_Status status;
-   eo_do(dbus_proxy, status = efl_model_property_get("nonexistent", &property_value));
+   status = efl_model_property_get(dbus_proxy, "nonexistent", &property_value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -79,7 +79,7 @@ START_TEST(property_set)
    eina_value_setup(&value, EINA_VALUE_TYPE_INT);
    eina_value_set(&value, 1);
    Efl_Model_Load_Status status;
-   eo_do(dbus_proxy, status = efl_model_property_set("nonexistent", &value));
+   status = efl_model_property_set(dbus_proxy, "nonexistent", &value);
    eina_value_flush(&value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
@@ -105,7 +105,7 @@ START_TEST(children_slice_get)
    // Unloaded dbus_proxy must return EFL_MODEL_LOAD_STATUS_UNLOADED
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(unloaded_dbus_proxy, status = efl_model_children_slice_get(0, 0, &accessor));
+   status = efl_model_children_slice_get(unloaded_dbus_proxy, 0, 0, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_UNLOADED, status);
    ck_assert_ptr_eq(NULL, accessor);
 }
@@ -114,7 +114,7 @@ END_TEST
 START_TEST(unload)
 {
    check_efl_model_load_status_get(dbus_proxy, EFL_MODEL_LOAD_STATUS_LOADED);
-   eo_do(dbus_proxy, efl_model_unload());
+   efl_model_unload(dbus_proxy);
    check_efl_model_load_status_get(dbus_proxy, EFL_MODEL_LOAD_STATUS_UNLOADED);
 
    check_efl_model_children_count_eq(dbus_proxy, 0);
@@ -123,14 +123,14 @@ END_TEST
 
 START_TEST(properties_load)
 {
-   eo_do(unloaded_dbus_proxy, efl_model_properties_load());
+   efl_model_properties_load(unloaded_dbus_proxy);
    check_efl_model_load_status_get(unloaded_dbus_proxy, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
 }
 END_TEST
 
 START_TEST(children_load)
 {
-   eo_do(unloaded_dbus_proxy, efl_model_children_load());
+   efl_model_children_load(unloaded_dbus_proxy);
 
    efl_model_wait_for_load_status(unloaded_dbus_proxy, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
 
@@ -143,7 +143,7 @@ END_TEST
 START_TEST(child_add)
 {
    Eo *child;
-   eo_do(dbus_proxy, child = efl_model_child_add());
+   child = efl_model_child_add(dbus_proxy);
    ck_assert_ptr_eq(NULL, child);
 }
 END_TEST
@@ -152,15 +152,15 @@ START_TEST(child_del)
 {
    unsigned int expected_children_count = 0;
    Efl_Model_Load_Status status;
-   eo_do(dbus_proxy, status = efl_model_children_count_get(&expected_children_count));
+   status = efl_model_children_count_get(dbus_proxy, &expected_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    Eo *child = efl_model_first_child_get(dbus_proxy);
-   eo_do(dbus_proxy, status = efl_model_child_del(child));
+   status = efl_model_child_del(dbus_proxy, child);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    unsigned int actual_children_count = 0;
-   eo_do(dbus_proxy, status = efl_model_children_count_get(&actual_children_count));
+   status = efl_model_children_count_get(dbus_proxy, &actual_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    ck_assert_int_le(expected_children_count, actual_children_count);
diff --git a/src/tests/eldbus/eldbus_test_eldbus_model_signal.c b/src/tests/eldbus/eldbus_test_eldbus_model_signal.c
index 3185f2e..7c31874 100644
--- a/src/tests/eldbus/eldbus_test_eldbus_model_signal.c
+++ b/src/tests/eldbus/eldbus_test_eldbus_model_signal.c
@@ -27,12 +27,7 @@ _setup(void)
 
    fake_server = fake_server_start(&fake_server_data);
 
-   fake_server_object = eo_add(ELDBUS_MODEL_OBJECT_CLASS, NULL,
-     eldbus_model_object_constructor(ELDBUS_CONNECTION_TYPE_SESSION,
-                                     NULL,
-                                     EINA_FALSE,
-                                     FAKE_SERVER_BUS,
-                                     FAKE_SERVER_PATH));
+   fake_server_object = eo_add(ELDBUS_MODEL_OBJECT_CLASS, NULL, eldbus_model_object_constructor(eoid, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
    ck_assert_ptr_ne(NULL, fake_server_object);
 
    efl_model_load_and_wait_for_load_status(fake_server_object, EFL_MODEL_LOAD_STATUS_LOADED);
@@ -68,7 +63,7 @@ START_TEST(properties_get)
 {
    Eina_Array *properties = NULL;
    Efl_Model_Load_Status status;
-   eo_do(pong_signal, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(pong_signal, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, properties);
 
@@ -83,12 +78,12 @@ START_TEST(property_get)
    // Signal properties always have output direction
    Eina_Value const* dummy;
    Efl_Model_Load_Status status;
-   eo_do(pong_signal, status = efl_model_property_get(ARGUMENT_A, &dummy));
+   status = efl_model_property_get(pong_signal, ARGUMENT_A, &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, dummy);
 
    // Nonexistent property must return EFL_MODEL_LOAD_STATUS_ERROR
-   eo_do(pong_signal, status = efl_model_property_get("nonexistent", &dummy));
+   status = efl_model_property_get(pong_signal, "nonexistent", &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -98,7 +93,7 @@ START_TEST(property_set)
    // Signals have output arguments only. All returns error
    Eina_Value dummy = {0};
    Efl_Model_Load_Status status;
-   eo_do(pong_signal, status = efl_model_property_set(ARGUMENT_A, &dummy));
+   status = efl_model_property_set(pong_signal, ARGUMENT_A, &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -119,7 +114,7 @@ START_TEST(children_slice_get)
 {
    Eina_Accessor *accessor;
    Efl_Model_Load_Status status;
-   eo_do(pong_signal, status = efl_model_children_slice_get(1, 1, &accessor));
+   status = efl_model_children_slice_get(pong_signal, 1, 1, &accessor);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_eq(NULL, accessor);
 }
@@ -129,7 +124,7 @@ static void
 _check_unload(void)
 {
    check_efl_model_load_status_get(pong_signal, EFL_MODEL_LOAD_STATUS_LOADED);
-   eo_do(pong_signal, efl_model_unload());
+   efl_model_unload(pong_signal);
    check_efl_model_load_status_get(pong_signal, EFL_MODEL_LOAD_STATUS_UNLOADED);
 
    check_efl_model_children_count_eq(pong_signal, 0);
@@ -145,7 +140,7 @@ START_TEST(properties_load)
 {
    _check_unload();
 
-   eo_do(pong_signal, efl_model_properties_load());
+   efl_model_properties_load(pong_signal);
    efl_model_wait_for_load_status(pong_signal, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
 
    check_efl_model_load_status_get(pong_signal, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
@@ -156,7 +151,7 @@ START_TEST(children_load)
 {
    _check_unload();
 
-   eo_do(pong_signal, efl_model_children_load());
+   efl_model_children_load(pong_signal);
    efl_model_wait_for_load_status(pong_signal, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
 
    check_efl_model_load_status_get(pong_signal, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
@@ -168,7 +163,7 @@ END_TEST
 START_TEST(child_add)
 {
    Eo *child;
-   eo_do(pong_signal, child = efl_model_child_add());
+   child = efl_model_child_add(pong_signal);
    ck_assert_ptr_eq(NULL, child);
 }
 END_TEST
@@ -178,7 +173,7 @@ START_TEST(child_del)
    // efl_model_child_del always returns ERROR
    Eo *child = NULL;
    Efl_Model_Load_Status status;
-   eo_do(pong_signal, status = efl_model_child_del(child));
+   status = efl_model_child_del(pong_signal, child);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 }
 END_TEST
@@ -193,7 +188,7 @@ START_TEST(signals)
    check_efl_model_property_int_set(ping_method, ARGUMENT_A, 99);
 
    Efl_Model_Load_Status status;
-   eo_do(ping_method, status = eldbus_model_method_call());
+   status = eldbus_model_method_call(ping_method);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    efl_model_wait_for_event(pong_signal, EFL_MODEL_BASE_EVENT_PROPERTIES_CHANGED);
diff --git a/src/tests/eldbus/eldbus_test_fake_server_eldbus_model_proxy.c b/src/tests/eldbus/eldbus_test_fake_server_eldbus_model_proxy.c
index 7a12d32..09ef4cc 100644
--- a/src/tests/eldbus/eldbus_test_fake_server_eldbus_model_proxy.c
+++ b/src/tests/eldbus/eldbus_test_fake_server_eldbus_model_proxy.c
@@ -33,12 +33,7 @@ _setup(void)
    };
    fake_server = fake_server_start(&fake_server_data);
 
-   fake_server_object = eo_add(ELDBUS_MODEL_OBJECT_CLASS, NULL,
-     eldbus_model_object_constructor(ELDBUS_CONNECTION_TYPE_SESSION,
-                                     NULL,
-                                     EINA_FALSE,
-                                     FAKE_SERVER_BUS,
-                                     FAKE_SERVER_PATH));
+   fake_server_object = eo_add(ELDBUS_MODEL_OBJECT_CLASS, NULL, eldbus_model_object_constructor(eoid, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
    ck_assert_ptr_ne(NULL, fake_server_object);
 
    efl_model_load_and_wait_for_load_status(fake_server_object, EFL_MODEL_LOAD_STATUS_LOADED);
@@ -70,7 +65,7 @@ START_TEST(properties_get)
 {
    Eina_Array *properties = NULL;
    Efl_Model_Load_Status status;
-   eo_do(fake_server_proxy, status = efl_model_properties_get(&properties));
+   status = efl_model_properties_get(fake_server_proxy, &properties);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
    ck_assert_ptr_ne(NULL, properties);
 
@@ -90,7 +85,7 @@ START_TEST(property_get)
    // Write-only property returns error
    const Eina_Value *dummy;
    Efl_Model_Load_Status status;
-   eo_do(fake_server_proxy, status = efl_model_property_get(FAKE_SERVER_WRITEONLY_PROPERTY, &dummy));
+   status = efl_model_property_get(fake_server_proxy, FAKE_SERVER_WRITEONLY_PROPERTY, &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    _teardown();
@@ -104,7 +99,7 @@ _check_property_set(const char *property_name, int expected_property_value, int
    eina_value_setup(&value, EINA_VALUE_TYPE_INT);
    eina_value_set(&value, expected_property_value);
    Efl_Model_Load_Status status;
-   eo_do(fake_server_proxy, status = efl_model_property_set(property_name, &value));
+   status = efl_model_property_set(fake_server_proxy, property_name, &value);
    eina_value_flush(&value);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
@@ -121,7 +116,7 @@ START_TEST(property_set)
    // Read-only property returns error
    Eina_Value dummy = {0};
    Efl_Model_Load_Status status;
-   eo_do(fake_server_proxy, status = efl_model_property_set(FAKE_SERVER_READONLY_PROPERTY, &dummy));
+   status = efl_model_property_set(fake_server_proxy, FAKE_SERVER_READONLY_PROPERTY, &dummy);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    _teardown();
@@ -149,9 +144,9 @@ START_TEST(children_slice_get)
    Eldbus_Model_Arguments *method2 = efl_model_nth_child_get(fake_server_proxy, 2);
    Eldbus_Model_Arguments *signal1 = efl_model_nth_child_get(fake_server_proxy, 3);
 
-   const char *actual_method1_name = eo_do_ret(method1, actual_method1_name, eldbus_model_arguments_name_get());
-   const char *actual_method2_name = eo_do_ret(method2, actual_method2_name, eldbus_model_arguments_name_get());
-   const char *actual_signal1_name = eo_do_ret(signal1, actual_signal1_name, eldbus_model_arguments_name_get());
+   const char *actual_method1_name = eldbus_model_arguments_name_get(method1);
+   const char *actual_method2_name = eldbus_model_arguments_name_get(method2);
+   const char *actual_signal1_name = eldbus_model_arguments_name_get(signal1);
 
    ck_assert_ptr_ne(NULL, actual_method1_name);
    ck_assert_ptr_ne(NULL, actual_method2_name);
@@ -173,7 +168,7 @@ static void
 _check_unload(void)
 {
    check_efl_model_load_status_get(fake_server_proxy, EFL_MODEL_LOAD_STATUS_LOADED);
-   eo_do(fake_server_proxy, efl_model_unload());
+   efl_model_unload(fake_server_proxy);
    check_efl_model_load_status_get(fake_server_proxy, EFL_MODEL_LOAD_STATUS_UNLOADED);
 
    check_efl_model_children_count_eq(fake_server_proxy, 0);
@@ -191,7 +186,7 @@ START_TEST(properties_load)
 {
    _check_unload();
 
-   eo_do(fake_server_proxy, efl_model_properties_load());
+   efl_model_properties_load(fake_server_proxy);
    efl_model_wait_for_load_status(fake_server_proxy, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
 
    check_efl_model_load_status_get(fake_server_proxy, EFL_MODEL_LOAD_STATUS_LOADED_PROPERTIES);
@@ -204,7 +199,7 @@ START_TEST(children_load)
 {
    _check_unload();
 
-   eo_do(fake_server_proxy, efl_model_children_load());
+   efl_model_children_load(fake_server_proxy);
    efl_model_wait_for_load_status(fake_server_proxy, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
 
    check_efl_model_load_status_get(fake_server_proxy, EFL_MODEL_LOAD_STATUS_LOADED_CHILDREN);
@@ -217,7 +212,7 @@ END_TEST
 
 START_TEST(child_add)
 {
-   Eo *child = eo_do_ret(fake_server_proxy, child, efl_model_child_add());
+   Eo *child = efl_model_child_add(fake_server_proxy);
    ck_assert_ptr_eq(NULL, child);
 
    _teardown();
@@ -229,16 +224,16 @@ START_TEST(child_del)
    // Tests that it is not possible to delete children
    unsigned int expected_children_count = 0;
    Efl_Model_Load_Status status;
-   eo_do(fake_server_proxy, status = efl_model_children_count_get(&expected_children_count));
+   status = efl_model_children_count_get(fake_server_proxy, &expected_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    // efl_model_child_del always returns ERROR
    Eo *child = efl_model_first_child_get(fake_server_proxy);
-   eo_do(fake_server_proxy, status = efl_model_child_del(child));
+   status = efl_model_child_del(fake_server_proxy, child);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_ERROR, status);
 
    unsigned int actual_children_count = 0;
-   eo_do(fake_server_proxy, status = efl_model_children_count_get(&actual_children_count));
+   status = efl_model_children_count_get(fake_server_proxy, &actual_children_count);
    ck_assert_int_eq(EFL_MODEL_LOAD_STATUS_LOADED, status);
 
    ck_assert_int_le(expected_children_count, actual_children_count);
diff --git a/src/tests/emotion/emotion_test_main-eo.c b/src/tests/emotion/emotion_test_main-eo.c
index 4efbfc9..f88e045 100644
--- a/src/tests/emotion/emotion_test_main-eo.c
+++ b/src/tests/emotion/emotion_test_main-eo.c
@@ -76,7 +76,7 @@ static const char  *theme_file = NULL;
 static void
 bg_resize(Evas_Coord w, Evas_Coord h)
 {
-   eo_do(o_bg, efl_gfx_size_set(w, h));
+   efl_gfx_size_set(o_bg, w, h);
 }
 
 static void
@@ -84,8 +84,7 @@ main_resize(Ecore_Evas *ee)
 {
    Evas_Coord w, h;
 
-   eo_do(ecore_evas_get(ee),
-         evas_canvas_output_viewport_get(NULL, NULL, &w, &h));
+   evas_canvas_output_viewport_get(ecore_evas_get(ee), NULL, NULL, &w, &h);
    bg_resize(w, h);
 }
 
@@ -113,15 +112,13 @@ static void
 bg_setup(void)
 {
    o_bg = eo_add(EDJE_OBJECT_CLASS, evas);
-   eo_do(o_bg, efl_file_set(theme_file, "background"),
-         efl_gfx_position_set(0, 0),
-         efl_gfx_size_set(startw, starth),
-         efl_gfx_stack_layer_set(-999),
-         efl_gfx_visible_set(EINA_TRUE),
-         evas_obj_focus_set(EINA_TRUE),
-
-         eo_event_callback_add(EVAS_OBJECT_EVENT_KEY_DOWN,
-            bg_key_down, NULL));
+   efl_file_set(o_bg, theme_file, "background");
+   efl_gfx_position_set(o_bg, 0, 0);
+   efl_gfx_size_set(o_bg, startw, starth);
+   efl_gfx_stack_layer_set(o_bg, -999);
+   efl_gfx_visible_set(o_bg, EINA_TRUE);
+   evas_obj_focus_set(o_bg, EINA_TRUE);
+   eo_event_callback_add(o_bg, EVAS_OBJECT_EVENT_KEY_DOWN, bg_key_down, NULL);
 }
 
 static void
@@ -309,7 +306,7 @@ video_obj_time_changed(Evas_Object *obj, Evas_Object *edje)
    pos = emotion_object_position_get(obj);
    len = emotion_object_play_length_get(obj);
    scale = (len > 0.0) ? pos / len : 0.0;
-   eo_do(edje, edje_obj_part_drag_value_set("video_progress", scale, 0.0));
+   edje_obj_part_drag_value_set(edje, "video_progress", scale, 0.0);
 
    lh = len / 3600;
    lm = len / 60 - (lh * 60);
@@ -323,7 +320,7 @@ video_obj_time_changed(Evas_Object *obj, Evas_Object *edje)
 
    snprintf(buf, sizeof(buf), "%i:%02i:%02i.%02i / %i:%02i:%02i",
             ph, pm, ps, pf, lh, lm, ls);
-   eo_do(edje, edje_obj_part_text_set("video_progress_txt", buf));
+   edje_obj_part_text_set(edje, "video_progress_txt", buf);
 }
 
 static Eina_Bool
@@ -356,12 +353,11 @@ video_obj_frame_resize_cb(void *data, const Eo_Event *event)
    printf("HANDLE %ix%i @ %3.3f\n", iw, ih, ratio);
    if (ratio > 0.0) iw = (ih * ratio) + 0.5;
    evas_object_size_hint_min_set(event->obj, iw, ih);
-   eo_do(oe, edje_obj_part_swallow( "video_swallow", event->obj),
-         edje_obj_size_min_calc(&w, &h),
-         efl_gfx_size_set(w, h)
-        );
-   eo_do(event->obj, evas_obj_size_hint_min_set(0, 0));
-   eo_do(oe, edje_obj_part_swallow( "video_swallow", event->obj));
+   edje_obj_part_swallow(oe, "video_swallow", event->obj);
+   edje_obj_size_min_calc(oe, &w, &h);
+   efl_gfx_size_set(oe, w, h);
+   evas_obj_size_hint_min_set(event->obj, 0, 0);
+   edje_obj_part_swallow(oe, "video_swallow", event->obj);
 
    return EINA_TRUE;
 }
@@ -459,7 +455,7 @@ video_obj_signal_play_cb(void *data, Evas_Object *o, const char *emission EINA_U
 {
    Evas_Object *ov = data;
    emotion_object_play_set(ov, EINA_TRUE);
-   eo_do(o, edje_obj_signal_emit("video_state", "play"));
+   edje_obj_signal_emit(o, "video_state", "play");
 }
 
 static void
@@ -467,7 +463,7 @@ video_obj_signal_pause_cb(void *data, Evas_Object *o, const char *emission EINA_
 {
    Evas_Object *ov = data;
    emotion_object_play_set(ov, EINA_FALSE);
-   eo_do(o, edje_obj_signal_emit("video_state", "pause"));
+   edje_obj_signal_emit(o, "video_state", "pause");
 }
 
 static void
@@ -476,7 +472,7 @@ video_obj_signal_stop_cb(void *data, Evas_Object *o, const char *emission EINA_U
    Evas_Object *ov = data;
    emotion_object_play_set(ov, EINA_FALSE);
    emotion_object_position_set(ov, 0.0);
-   eo_do(o, edje_obj_signal_emit("video_state", "stop"));
+   edje_obj_signal_emit(o, "video_state", "stop");
 }
 
 static void
@@ -486,7 +482,7 @@ video_obj_signal_jump_cb(void *data, Evas_Object *o, const char *emission EINA_U
    double len;
    double x, y;
 
-   eo_do(o, edje_obj_part_drag_value_get(source, &x, &y));
+   edje_obj_part_drag_value_get(o, source, &x, &y);
    len = emotion_object_play_length_get(ov);
    emotion_object_position_set(ov, x * len);
 }
@@ -499,11 +495,11 @@ video_obj_signal_alpha_cb(void *data, Evas_Object *o, const char *emission EINA_
    double x, y;
    char buf[256];
 
-   eo_do(o, edje_obj_part_drag_value_get(source, &x, &y));
+   edje_obj_part_drag_value_get(o, source, &x, &y);
    alpha = 255 * y;
-   eo_do(ov, efl_gfx_color_set(alpha, alpha, alpha, alpha));
+   efl_gfx_color_set(ov, alpha, alpha, alpha, alpha);
    snprintf(buf, sizeof(buf), "alpha %.0f", alpha);
-   eo_do(o, edje_obj_part_text_set("video_alpha_txt", buf));
+   edje_obj_part_text_set(o, "video_alpha_txt", buf);
 }
 
 static void
@@ -513,10 +509,10 @@ video_obj_signal_vol_cb(void *data, Evas_Object *o, const char *emission EINA_UN
    double vol;
    char buf[256];
 
-   eo_do(o, edje_obj_part_drag_value_get(source, NULL, &vol));
+   edje_obj_part_drag_value_get(o, source, NULL, &vol);
    emotion_object_audio_volume_set(ov, vol);
    snprintf(buf, sizeof(buf), "vol %.2f", vol);
-   eo_do(o, edje_obj_part_text_set("video_volume_txt", buf));
+   edje_obj_part_text_set(o, "video_volume_txt", buf);
 }
 
 static void
@@ -525,14 +521,13 @@ video_obj_signal_frame_move_start_cb(void *data EINA_UNUSED, Evas_Object *o, con
    Frame_Data *fd;
    Evas_Coord x, y;
 
-   eo_do(o, fd = eo_key_data_get("frame_data"));
+   fd = eo_key_data_get(o, "frame_data");
    if (!fd) return;
    fd->moving = 1;
-   eo_do(evas_object_evas_get(o),
-         evas_canvas_pointer_canvas_xy_get(&x, &y));
+   evas_canvas_pointer_canvas_xy_get(evas_object_evas_get(o), &x, &y);
    fd->x = x;
    fd->y = y;
-   eo_do(o, efl_gfx_stack_raise());
+   efl_gfx_stack_raise(o);
 }
 
 static void
@@ -540,7 +535,7 @@ video_obj_signal_frame_move_stop_cb(void *data EINA_UNUSED, Evas_Object *o, cons
 {
    Frame_Data *fd;
 
-   eo_do(o, fd = eo_key_data_get("frame_data"));
+   fd = eo_key_data_get(o, "frame_data");
    if (!fd) return;
    fd->moving = 0;
 }
@@ -551,14 +546,13 @@ video_obj_signal_frame_resize_start_cb(void *data EINA_UNUSED, Evas_Object *o, c
    Frame_Data *fd;
    Evas_Coord x, y;
 
-   eo_do(o, fd = eo_key_data_get("frame_data"));
+   fd = eo_key_data_get(o, "frame_data");
    if (!fd) return;
    fd->resizing = 1;
-   eo_do(evas_object_evas_get(o),
-         evas_canvas_pointer_canvas_xy_get(&x, &y));
+   evas_canvas_pointer_canvas_xy_get(evas_object_evas_get(o), &x, &y);
    fd->x = x;
    fd->y = y;
-   eo_do(o, efl_gfx_stack_raise());
+   efl_gfx_stack_raise(o);
 }
 
 static void
@@ -566,7 +560,7 @@ video_obj_signal_frame_resize_stop_cb(void *data EINA_UNUSED, Evas_Object *o, co
 {
    Frame_Data *fd;
 
-   eo_do(o, fd = eo_key_data_get("frame_data"));
+   fd = eo_key_data_get(o, "frame_data");
    if (!fd) return;
    fd->resizing = 0;
 }
@@ -576,18 +570,15 @@ video_obj_signal_frame_move_cb(void *data EINA_UNUSED, Evas_Object *o, const cha
 {
    Frame_Data *fd;
 
-   eo_do(o, fd = eo_key_data_get("frame_data"));
+   fd = eo_key_data_get(o, "frame_data");
    if (!fd) return;
    if (fd->moving)
      {
         Evas_Coord x, y, ox, oy;
 
-        eo_do(evas_object_evas_get(o),
-              evas_canvas_pointer_canvas_xy_get(&x, &y));
-        eo_do(o,
-              efl_gfx_position_get(&ox, &oy),
-              efl_gfx_position_set(ox + (x - fd->x), oy + (y - fd->y))
-             );
+        evas_canvas_pointer_canvas_xy_get(evas_object_evas_get(o), &x, &y);
+        efl_gfx_position_get(o, &ox, &oy);
+        efl_gfx_position_set(o, ox + (x - fd->x), oy + (y - fd->y));
         fd->x = x;
         fd->y = y;
      }
@@ -595,9 +586,8 @@ video_obj_signal_frame_move_cb(void *data EINA_UNUSED, Evas_Object *o, const cha
      {
         Evas_Coord x, y, ow, oh;
 
-        eo_do(evas_object_evas_get(o),
-              evas_canvas_pointer_canvas_xy_get(&x, &y));
-        eo_do(o, efl_gfx_size_get(&ow, &oh));
+        evas_canvas_pointer_canvas_xy_get(evas_object_evas_get(o), &x, &y);
+        efl_gfx_size_get(o, &ow, &oh);
         evas_object_resize(o, ow + (x - fd->x), oh + (y - fd->y));
         fd->x = x;
         fd->y = y;
@@ -650,43 +640,35 @@ init_video_object(const char *module_filename, const char *filename)
    if (!fd) exit(1);
 
    oe = eo_add(EDJE_OBJECT_CLASS, evas);
-   eo_do(oe,
-         eo_event_callback_add(EVAS_OBJECT_EVENT_FREE, _oe_free_cb, fd),
-         eo_key_data_set("frame_data", fd),
-         efl_file_set(theme_file,
-            reflex ? "video_controller/reflex" : "video_controller"),
-         edje_obj_part_swallow("video_swallow", o));
+   eo_event_callback_add(oe, EVAS_OBJECT_EVENT_FREE, _oe_free_cb, fd);
+   eo_key_data_set(oe, "frame_data", fd);
+   efl_file_set(oe, theme_file, reflex ? "video_controller/reflex" : "video_controller");
+   edje_obj_part_swallow(oe, "video_swallow", o);
 
    offset = 20 * (eina_list_count(video_objs) - 1);
-   eo_do(oe,
-         efl_gfx_position_set(offset, offset),
-         edje_obj_size_min_calc(&w, &h),
-         efl_gfx_size_set(w, h));
-
-   eo_do(o, eo_event_callback_array_add(emotion_object_test_callbacks, oe));
-
-   eo_do(oe,
-         edje_obj_signal_callback_add("video_control", "play", video_obj_signal_play_cb, o),
-         edje_obj_signal_callback_add("video_control", "pause", video_obj_signal_pause_cb, o),
-         edje_obj_signal_callback_add("video_control", "stop", video_obj_signal_stop_cb, o),
-         edje_obj_signal_callback_add("drag", "video_progress", video_obj_signal_jump_cb, o),
-         edje_obj_signal_callback_add("drag", "video_alpha", video_obj_signal_alpha_cb, o),
-         edje_obj_signal_callback_add("drag", "video_volume", video_obj_signal_vol_cb, o),
-
-         edje_obj_signal_callback_add("frame_move", "start", video_obj_signal_frame_move_start_cb, oe),
-         edje_obj_signal_callback_add("frame_move", "stop", video_obj_signal_frame_move_stop_cb, oe),
-         edje_obj_signal_callback_add("frame_resize", "start", video_obj_signal_frame_resize_start_cb, oe),
-         edje_obj_signal_callback_add("frame_resize", "stop", video_obj_signal_frame_resize_stop_cb, oe),
-         edje_obj_signal_callback_add("mouse,move", "*", video_obj_signal_frame_move_cb, oe),
-
-         edje_obj_part_drag_value_set("video_alpha", 0.0, 1.0),
-         edje_obj_part_text_set("video_alpha_txt", "alpha 255"),
-         edje_obj_part_drag_value_set("video_volume", 0.0, 0.5),
-         edje_obj_part_text_set("video_volume_txt", "vol 0.50"),
-
-         edje_obj_signal_emit("video_state", "play"),
-
-         efl_gfx_visible_set(EINA_TRUE));
+   efl_gfx_position_set(oe, offset, offset);
+   edje_obj_size_min_calc(oe, &w, &h);
+   efl_gfx_size_set(oe, w, h);
+
+   eo_event_callback_array_add(o, emotion_object_test_callbacks, oe);
+
+   edje_obj_signal_callback_add(oe, "video_control", "play", video_obj_signal_play_cb, o);
+   edje_obj_signal_callback_add(oe, "video_control", "pause", video_obj_signal_pause_cb, o);
+   edje_obj_signal_callback_add(oe, "video_control", "stop", video_obj_signal_stop_cb, o);
+   edje_obj_signal_callback_add(oe, "drag", "video_progress", video_obj_signal_jump_cb, o);
+   edje_obj_signal_callback_add(oe, "drag", "video_alpha", video_obj_signal_alpha_cb, o);
+   edje_obj_signal_callback_add(oe, "drag", "video_volume", video_obj_signal_vol_cb, o);
+   edje_obj_signal_callback_add(oe, "frame_move", "start", video_obj_signal_frame_move_start_cb, oe);
+   edje_obj_signal_callback_add(oe, "frame_move", "stop", video_obj_signal_frame_move_stop_cb, oe);
+   edje_obj_signal_callback_add(oe, "frame_resize", "start", video_obj_signal_frame_resize_start_cb, oe);
+   edje_obj_signal_callback_add(oe, "frame_resize", "stop", video_obj_signal_frame_resize_stop_cb, oe);
+   edje_obj_signal_callback_add(oe, "mouse, move", "*", video_obj_signal_frame_move_cb, oe);
+   edje_obj_part_drag_value_set(oe, "video_alpha", 0.0, 1.0);
+   edje_obj_part_text_set(oe, "video_alpha_txt", "alpha 255");
+   edje_obj_part_drag_value_set(oe, "video_volume", 0.0, 0.5);
+   edje_obj_part_text_set(oe, "video_volume_txt", "vol 0.50");
+   edje_obj_signal_emit(oe, "video_state", "play");
+   efl_gfx_visible_set(oe, EINA_TRUE);
 }
 
 int
diff --git a/src/tests/eo/access/access_main.c b/src/tests/eo/access/access_main.c
index 61cd381..d8d825b 100644
--- a/src/tests/eo/access/access_main.c
+++ b/src/tests/eo/access/access_main.c
@@ -15,7 +15,8 @@ main(int argc, char *argv[])
 
    Eo *obj = eo_add(INHERIT_CLASS, NULL);
 
-   eo_do(obj, simple_a_set(1), inherit_prot_print());
+   simple_a_set(obj, 1);
+   inherit_prot_print(obj);
 
    Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS);
    printf("Pub: %d\n", pd->public_x2);
diff --git a/src/tests/eo/access/access_simple.c b/src/tests/eo/access/access_simple.c
index 55e55e0..b4f8766 100644
--- a/src/tests/eo/access/access_simple.c
+++ b/src/tests/eo/access/access_simple.c
@@ -27,7 +27,7 @@ _a_set(Eo *obj, void *class_data, int a)
    pd->protected.protected_x1 = a + 1;
    pd->protected.public.public_x2 = a + 2;
 
-   eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a));
+   eo_event_callback_call(obj, EV_A_CHANGED, &pd->a);
 }
 
 EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a);
diff --git a/src/tests/eo/children/children_main.c b/src/tests/eo/children/children_main.c
index 0e0832f..8935228 100644
--- a/src/tests/eo/children/children_main.c
+++ b/src/tests/eo/children/children_main.c
@@ -28,7 +28,7 @@ main(int argc, char *argv[])
    Eo *child2 = eo_add(SIMPLE_CLASS, parent);
    Eo *child3 = eo_add(SIMPLE_CLASS, parent);
 
-   eo_do(parent, iter = eo_children_iterator_new());
+   iter = eo_children_iterator_new(parent);
    fail_if(!iter);
 
    CHECK_ITER_DATA(iter, chld, child1);
@@ -40,7 +40,7 @@ main(int argc, char *argv[])
 
    eo_del(child2);
 
-   eo_do(parent, iter = eo_children_iterator_new());
+   iter = eo_children_iterator_new(parent);
    fail_if(!iter);
 
    CHECK_ITER_DATA(iter, chld, child1);
@@ -52,7 +52,7 @@ main(int argc, char *argv[])
 
    eo_del(child1);
 
-   eo_do(parent, iter = eo_children_iterator_new());
+   iter = eo_children_iterator_new(parent);
    fail_if(!iter);
 
    CHECK_ITER_DATA(iter, chld, child3);
@@ -62,7 +62,7 @@ main(int argc, char *argv[])
 
    eo_del(child3);
 
-   eo_do(parent, iter = eo_children_iterator_new());
+   iter = eo_children_iterator_new(parent);
    fail_if(iter);
 
    eo_unref(parent);
diff --git a/src/tests/eo/composite_objects/composite_objects_comp.c b/src/tests/eo/composite_objects/composite_objects_comp.c
index 32116c9..59ab956 100644
--- a/src/tests/eo/composite_objects/composite_objects_comp.c
+++ b/src/tests/eo/composite_objects/composite_objects_comp.c
@@ -16,7 +16,7 @@ static int
 _a_get(Eo *obj, void *class_data EINA_UNUSED)
 {
    int a = 0;
-   eo_do_super(obj, MY_CLASS, a = simple_a_get());
+   a = simple_a_get(eo_super(obj, MY_CLASS));
 
    return a;
 }
@@ -25,16 +25,16 @@ static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
    Eina_Bool tmp;
-   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   obj = eo_constructor(eo_super(obj, MY_CLASS));
 
    Eo *simple = eo_add(SIMPLE_CLASS, obj);
-   eo_do(obj, eo_composite_attach(simple));
-   eo_do(simple, eo_event_callback_forwarder_add(EV_A_CHANGED, obj));
+   eo_composite_attach(obj, simple);
+   eo_event_callback_forwarder_add(simple, EV_A_CHANGED, obj);
 
-   fail_if(eo_do_ret(obj, tmp, eo_composite_part_is()));
-   fail_if(!eo_do_ret(simple, tmp, eo_composite_part_is()));
+   fail_if(eo_composite_part_is(obj));
+   fail_if(!eo_composite_part_is(simple));
 
-   eo_do(obj, eo_key_data_set("simple-obj", simple));
+   eo_key_data_set(obj, "simple-obj", simple);
 
    return obj;
 }
diff --git a/src/tests/eo/composite_objects/composite_objects_main.c b/src/tests/eo/composite_objects/composite_objects_main.c
index 5ad11c6..9e90eb4 100644
--- a/src/tests/eo/composite_objects/composite_objects_main.c
+++ b/src/tests/eo/composite_objects/composite_objects_main.c
@@ -32,49 +32,49 @@ main(int argc, char *argv[])
    eo_init();
 
    Eo *obj = eo_add(COMP_CLASS, NULL);
-   eo_do(obj, eo_event_callback_add(EV_A_CHANGED, _a_changed_cb, NULL));
+   eo_event_callback_add(obj, EV_A_CHANGED, _a_changed_cb, NULL);
 
    fail_if(!eo_isa(obj, COMP_CLASS));
    fail_if(!eo_isa(obj, SIMPLE_CLASS));
 
    int a = 0;
    cb_called = EINA_FALSE;
-   eo_do(obj, simple_a_set(1));
+   simple_a_set(obj, 1);
    fail_if(!cb_called);
 
    /* Test functions from all across the chain. */
    cb_called = EINA_FALSE;
-   eo_do(obj, simple_a_set1(1));
+   simple_a_set1(obj, 1);
    fail_if(!cb_called);
    cb_called = EINA_FALSE;
-   eo_do(obj, simple_a_set15(1));
+   simple_a_set15(obj, 1);
    fail_if(!cb_called);
    cb_called = EINA_FALSE;
-   eo_do(obj, simple_a_set32(1));
+   simple_a_set32(obj, 1);
    fail_if(!cb_called);
 
-   eo_do(obj, a = simple_a_get());
+   a = simple_a_get(obj);
    fail_if(a != 1);
 
    /* disable the callback forwarder, and fail if it's still called. */
    Eo *simple = NULL;
-   eo_do(obj, simple = eo_key_data_get("simple-obj"));
+   simple = eo_key_data_get(obj, "simple-obj");
    eo_ref(simple);
-   eo_do(simple, eo_event_callback_forwarder_del(EV_A_CHANGED, obj));
+   eo_event_callback_forwarder_del(simple, EV_A_CHANGED, obj);
 
    cb_called = EINA_FALSE;
-   eo_do(obj, simple_a_set(2));
+   simple_a_set(obj, 2);
    fail_if(cb_called);
 
-   fail_if(!eo_do_ret(simple, tmp,eo_composite_part_is()));
-   fail_if(!eo_do_ret(obj, tmp,eo_composite_detach(simple)));
-   fail_if(eo_do_ret(obj, tmp,eo_composite_detach(simple)));
-   fail_if(eo_do_ret(simple, tmp,eo_composite_part_is()));
-   fail_if(!eo_do_ret(obj, tmp,eo_composite_attach(simple)));
-   fail_if(!eo_do_ret(simple, tmp,eo_composite_part_is()));
-   fail_if(eo_do_ret(obj, tmp,eo_composite_attach(simple)));
+   fail_if(!eo_composite_part_is(simple));
+   fail_if(!eo_composite_detach(obj, simple));
+   fail_if(eo_composite_detach(obj, simple));
+   fail_if(eo_composite_part_is(simple));
+   fail_if(!eo_composite_attach(obj, simple));
+   fail_if(!eo_composite_part_is(simple));
+   fail_if(eo_composite_attach(obj, simple));
 
-   fail_if(eo_do_ret(simple, tmp,eo_composite_attach(obj)));
+   fail_if(eo_composite_attach(simple, obj));
 
    eo_unref(simple);
    eo_unref(obj);
diff --git a/src/tests/eo/composite_objects/composite_objects_simple.c b/src/tests/eo/composite_objects/composite_objects_simple.c
index b9c906e..5c64cc0 100644
--- a/src/tests/eo/composite_objects/composite_objects_simple.c
+++ b/src/tests/eo/composite_objects/composite_objects_simple.c
@@ -17,7 +17,7 @@ _a_set(Eo *obj, void *class_data, int a)
    printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
    pd->a = a;
 
-   eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a));
+   eo_event_callback_call(obj, EV_A_CHANGED, &pd->a);
 }
 
 static int
diff --git a/src/tests/eo/constructors/constructors_main.c b/src/tests/eo/constructors/constructors_main.c
index cab5e7f..5844e46 100644
--- a/src/tests/eo/constructors/constructors_main.c
+++ b/src/tests/eo/constructors/constructors_main.c
@@ -28,10 +28,13 @@ main(int argc, char *argv[])
 
    fail_if(my_init_count != 2);
 
-   eo_do(obj, simple_a_set(1), simple_b_set(2));
+   simple_a_set(obj, 1);
+   simple_b_set(obj, 2);
 
    int a = 0, b = 0;
-   eo_do(obj, a = simple_a_get(), b = simple_b_get(), mixin_add_and_print(5));
+   a = simple_a_get(obj);
+   b = simple_b_get(obj);
+   mixin_add_and_print(obj, 5);
    fail_if(a != 1);
    fail_if(b != 2);
 
@@ -69,19 +72,18 @@ main(int argc, char *argv[])
    obj = eo_add(SIMPLE_CLASS, NULL);
    fail_if(!obj);
    fail_if(my_init_count != 2);
-   eo_do(obj, a = simple_a_get());
+   a = simple_a_get(obj);
    fail_if(a != 0);
 
    my_init_count = 0;
-   obj = eo_add(SIMPLE_CLASS, NULL, simple_a_set(7));
+   obj = eo_add(SIMPLE_CLASS, NULL, simple_a_set(eoid, 7));
    fail_if(!obj);
    fail_if(my_init_count != 2);
-   eo_do(obj, a = simple_a_get(););
+   a = simple_a_get(obj);
    fail_if(a != 7);
 
    my_init_count = 0;
-   obj = eo_add(SIMPLE_CLASS, NULL, simple_b_set(6), simple_a_set(-1),
-                b = simple_b_get());
+   obj = eo_add(SIMPLE_CLASS, NULL, simple_b_set(eoid, 6), simple_a_set(eoid, -1), b = simple_b_get(eoid));
    fail_if(obj);
    fail_if(b != 6);
    fail_if(my_init_count != 0);
diff --git a/src/tests/eo/constructors/constructors_mixin.c b/src/tests/eo/constructors/constructors_mixin.c
index 10213b1..b2e523b 100644
--- a/src/tests/eo/constructors/constructors_mixin.c
+++ b/src/tests/eo/constructors/constructors_mixin.c
@@ -12,7 +12,8 @@ static void
 _add_and_print_set(Eo *obj, void *class_data EINA_UNUSED, int x)
 {
    int a = 0, b = 0;
-   eo_do(obj, a = simple_a_get(), b = simple_b_get());
+   a = simple_a_get(obj);
+   b = simple_b_get(obj);
    printf("%s %d\n", __func__, a + b + x);
 }
 
@@ -23,13 +24,13 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
    my_init_count++;
 
-   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   return eo_constructor(eo_super(obj, MY_CLASS));
 }
 
 static void
 _destructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_destructor());
+   eo_destructor(eo_super(obj, MY_CLASS));
 
    my_init_count--;
 }
diff --git a/src/tests/eo/constructors/constructors_simple.c b/src/tests/eo/constructors/constructors_simple.c
index d287485..370ca60 100644
--- a/src/tests/eo/constructors/constructors_simple.c
+++ b/src/tests/eo/constructors/constructors_simple.c
@@ -44,7 +44,7 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
    my_init_count++;
 
-   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   return eo_constructor(eo_super(obj, MY_CLASS));
 }
 
 static Eo*
@@ -53,7 +53,7 @@ _finalize(Eo *obj, void *class_data EINA_UNUSED)
    Eo *ret;
    Private_Data *pd = class_data;
 
-   eo_do_super(obj, MY_CLASS, ret = eo_finalize());
+   ret = eo_finalize(eo_super(obj, MY_CLASS));
 
    if (pd->a < 0)
      {
@@ -66,7 +66,7 @@ _finalize(Eo *obj, void *class_data EINA_UNUSED)
 static void
 _destructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_destructor());
+   eo_destructor(eo_super(obj, MY_CLASS));
 
    my_init_count--;
 }
diff --git a/src/tests/eo/constructors/constructors_simple2.c b/src/tests/eo/constructors/constructors_simple2.c
index e0c6804..b1e59f8 100644
--- a/src/tests/eo/constructors/constructors_simple2.c
+++ b/src/tests/eo/constructors/constructors_simple2.c
@@ -11,7 +11,7 @@
 static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   obj = eo_constructor(eo_super(obj, MY_CLASS));
 
    return NULL;
 }
diff --git a/src/tests/eo/constructors/constructors_simple6.c b/src/tests/eo/constructors/constructors_simple6.c
index 9f4355d..f3e12b8 100644
--- a/src/tests/eo/constructors/constructors_simple6.c
+++ b/src/tests/eo/constructors/constructors_simple6.c
@@ -11,7 +11,7 @@
 static void
 _destructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_destructor());
+   eo_destructor(eo_super(obj, MY_CLASS));
 }
 
 static Eo_Op_Description op_descs [] = {
diff --git a/src/tests/eo/constructors/constructors_simple7.c b/src/tests/eo/constructors/constructors_simple7.c
index d3ec9ea..c821d25 100644
--- a/src/tests/eo/constructors/constructors_simple7.c
+++ b/src/tests/eo/constructors/constructors_simple7.c
@@ -15,7 +15,7 @@ static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
    /* FIXME: Actually test it. */
-   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   return eo_constructor(eo_super(obj, MY_CLASS));
 }
 
 static Eo_Op_Description op_descs [] = {
diff --git a/src/tests/eo/function_overrides/function_overrides_inherit2.c b/src/tests/eo/function_overrides/function_overrides_inherit2.c
index e250ee3..b4602aa 100644
--- a/src/tests/eo/function_overrides/function_overrides_inherit2.c
+++ b/src/tests/eo/function_overrides/function_overrides_inherit2.c
@@ -15,11 +15,11 @@ static void
 _a_set(Eo *obj, void *class_data EINA_UNUSED, int a)
 {
    printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
-   eo_do(obj, simple_a_print());
-   eo_do_super(obj, MY_CLASS, simple_a_set(a + 1));
+   simple_a_print(obj);
+   simple_a_set(eo_super(obj, MY_CLASS), a + 1);
 
    Eina_Bool called = EINA_FALSE;
-   eo_do_super(obj, MY_CLASS, called = simple_a_print());
+   called = simple_a_print(eo_super(obj, MY_CLASS));
    fail_if(!called);
 }
 
@@ -28,7 +28,7 @@ _print(Eo *obj, void *class_data EINA_UNUSED)
 {
    Eina_Bool called = EINA_FALSE;
    printf("Hey\n");
-   eo_do_super(obj, MY_CLASS, called = inherit2_print());
+   called = inherit2_print(eo_super(obj, MY_CLASS));
    fail_if(called);
 
    return EINA_TRUE;
@@ -47,10 +47,10 @@ _class_print(Eo_Class *klass, void *data EINA_UNUSED)
 {
    Eina_Bool called = EINA_FALSE;
    printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS));
-   eo_do_super(klass, MY_CLASS, called = simple_class_print());
+   called = simple_class_print(eo_super(klass, MY_CLASS));
    fail_if(!called);
 
-   eo_do_super(klass, MY_CLASS, called = simple_class_print2());
+   called = simple_class_print2(eo_super(klass, MY_CLASS));
    fail_if(!called);
 
    return EINA_TRUE;
diff --git a/src/tests/eo/function_overrides/function_overrides_inherit3.c b/src/tests/eo/function_overrides/function_overrides_inherit3.c
index 2f96d59..4c23281 100644
--- a/src/tests/eo/function_overrides/function_overrides_inherit3.c
+++ b/src/tests/eo/function_overrides/function_overrides_inherit3.c
@@ -13,7 +13,7 @@ static void
 _a_set(Eo *obj, void *class_data EINA_UNUSED, int a)
 {
    printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
-   eo_do_super(obj, MY_CLASS, simple_a_set(a + 1));
+   simple_a_set(eo_super(obj, MY_CLASS), a + 1);
 }
 
 static Eo_Op_Description op_descs[] = {
diff --git a/src/tests/eo/function_overrides/function_overrides_main.c b/src/tests/eo/function_overrides/function_overrides_main.c
index 920595c..b2aa840 100644
--- a/src/tests/eo/function_overrides/function_overrides_main.c
+++ b/src/tests/eo/function_overrides/function_overrides_main.c
@@ -20,7 +20,7 @@ main(int argc, char *argv[])
    Eina_Bool called = EINA_FALSE;
    Eo *obj = eo_add(INHERIT2_CLASS, NULL);
 
-   eo_do(obj, simple_a_set(1));
+   simple_a_set(obj, 1);
    Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS);
    fail_if(pd->a != 2);
 
@@ -28,47 +28,48 @@ main(int argc, char *argv[])
 
    obj = eo_add(INHERIT3_CLASS, NULL);
 
-   eo_do(obj, simple_a_set(1));
+   simple_a_set(obj, 1);
    pd = eo_data_scope_get(obj, SIMPLE_CLASS);
    fail_if(pd->a != 3);
 
    eo_unref(obj);
 
    obj = eo_add(INHERIT2_CLASS, NULL);
-   eo_do(obj, called = inherit2_print());
+   called = inherit2_print(obj);
    fail_if(!called);
-   eo_do(obj, called = inherit2_print(), called = inherit2_print());
+   called = inherit2_print(obj);
+   called = inherit2_print(obj);
    fail_if(!called);
    eo_unref(obj);
 
    obj = eo_add(SIMPLE_CLASS, NULL);
-   eo_do(obj, called = inherit2_print());
+   called = inherit2_print(obj);
    fail_if(called);
 
 #ifdef EO_DEBUG
-   eo_do(obj, called = simple_class_print());
+   called = simple_class_print(obj);
    fail_if(called);
 #endif
 
-   eo_do(SIMPLE_CLASS, called = simple_class_print());
+   called = simple_class_print(SIMPLE_CLASS);
    fail_if(!called);
 
-   eo_do(INHERIT_CLASS, called = simple_class_print());
+   called = simple_class_print(INHERIT_CLASS);
    fail_if(!called);
 
-   eo_do(INHERIT2_CLASS, called = simple_class_print());
+   called = simple_class_print(INHERIT2_CLASS);
    fail_if(!called);
 
-   eo_do(INHERIT3_CLASS, called = simple_class_print());
+   called = simple_class_print(INHERIT3_CLASS);
    fail_if(!called);
 
 #ifdef EO_DEBUG
-   eo_do(SIMPLE_CLASS, called = simple_a_print());
+   called = simple_a_print(SIMPLE_CLASS);
    fail_if(called);
 #endif
 
-   eo_do_super(obj, SIMPLE_CLASS, eo_constructor());
-   eo_do_super(obj, SIMPLE_CLASS, eo_destructor());
+   eo_constructor(eo_super(obj, SIMPLE_CLASS));
+   eo_destructor(eo_super(obj, SIMPLE_CLASS));
 
    eo_unref(obj);
 
diff --git a/src/tests/eo/function_overrides/function_overrides_simple.c b/src/tests/eo/function_overrides/function_overrides_simple.c
index dc5f0dd..57942f7 100644
--- a/src/tests/eo/function_overrides/function_overrides_simple.c
+++ b/src/tests/eo/function_overrides/function_overrides_simple.c
@@ -34,10 +34,10 @@ _class_print(Eo_Class *klass, void *class_data EINA_UNUSED)
 {
    printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS));
    Eina_Bool called = EINA_FALSE;
-   eo_do_super(klass, MY_CLASS, called = simple_class_print());
+   called = simple_class_print(eo_super(klass, MY_CLASS));
    fail_if(called);
 
-   eo_do_super(klass, MY_CLASS, called = simple_class_print2());
+   called = simple_class_print2(eo_super(klass, MY_CLASS));
    fail_if(called);
 
    return EINA_TRUE;
diff --git a/src/tests/eo/interface/interface_main.c b/src/tests/eo/interface/interface_main.c
index 40936d4..a85f030 100644
--- a/src/tests/eo/interface/interface_main.c
+++ b/src/tests/eo/interface/interface_main.c
@@ -18,16 +18,21 @@ main(int argc, char *argv[])
 
    Eo *obj = eo_add(SIMPLE_CLASS, NULL);
 
-   eo_do(obj, simple_a_set(1), simple_b_set(2));
+   simple_a_set(obj, 1);
+   simple_b_set(obj, 2);
 
    int a = 0, b = 0, sum = 0;
-   eo_do(obj, a = simple_a_get(), b = simple_b_get(), sum = interface_ab_sum_get());
+   a = simple_a_get(obj);
+   b = simple_b_get(obj);
+   sum = interface_ab_sum_get(obj);
    fail_if(sum != a + b);
 
    sum = 0;
-   eo_do(obj, sum = interface_ab_sum_get(), sum = interface_ab_sum_get());
+   sum = interface_ab_sum_get(obj);
+   sum = interface_ab_sum_get(obj);
    fail_if(sum != a + b);
-   eo_do(obj, sum = interface2_ab_sum_get2(), sum = interface2_ab_sum_get2());
+   sum = interface2_ab_sum_get2(obj);
+   sum = interface2_ab_sum_get2(obj);
    fail_if(sum != a + b + 1);
 
    eo_unref(obj);
diff --git a/src/tests/eo/interface/interface_simple.c b/src/tests/eo/interface/interface_simple.c
index cad7f24..589274f 100644
--- a/src/tests/eo/interface/interface_simple.c
+++ b/src/tests/eo/interface/interface_simple.c
@@ -40,7 +40,8 @@ static int
 _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
 {
    int a = 0, b = 0;
-   eo_do(obj, a = simple_a_get(), b = simple_b_get());
+   a = simple_a_get(obj);
+   b = simple_b_get(obj);
    printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
    return a + b;
 }
@@ -49,7 +50,8 @@ static int
 _ab_sum_get2(Eo *obj, void *class_data EINA_UNUSED)
 {
    int a = 0, b = 0;
-   eo_do(obj, a = simple_a_get(), b = simple_b_get());
+   a = simple_a_get(obj);
+   b = simple_b_get(obj);
    printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
    return a + b + 1;
 }
diff --git a/src/tests/eo/mixin/mixin_inherit.c b/src/tests/eo/mixin/mixin_inherit.c
index 8098c1c..b583bef 100644
--- a/src/tests/eo/mixin/mixin_inherit.c
+++ b/src/tests/eo/mixin/mixin_inherit.c
@@ -13,7 +13,7 @@ static int
 _a_get(Eo *obj, void *class_data EINA_UNUSED)
 {
    int ret = 0;
-   eo_do_super(obj, MY_CLASS, ret = simple_a_get());
+   ret = simple_a_get(eo_super(obj, MY_CLASS));
    printf("%s %d\n", __func__, ret);
 
    return ret;
diff --git a/src/tests/eo/mixin/mixin_main.c b/src/tests/eo/mixin/mixin_main.c
index 6ab6af2..d3c1dbf 100644
--- a/src/tests/eo/mixin/mixin_main.c
+++ b/src/tests/eo/mixin/mixin_main.c
@@ -20,13 +20,17 @@ main(int argc, char *argv[])
 
    Eo *obj = eo_add(SIMPLE_CLASS, NULL);
 
-   eo_do(obj, simple_a_set(1), simple_b_set(2));
+   simple_a_set(obj, 1);
+   simple_b_set(obj, 2);
 
    int a = 0, b = 0, sum = 0;
-   eo_do(obj, a = simple_a_get(), b = simple_b_get(), sum = mixin_ab_sum_get());
+   a = simple_a_get(obj);
+   b = simple_b_get(obj);
+   sum = mixin_ab_sum_get(obj);
    fail_if(sum != a + b + 2); /* 2 for the two mixins... */
 
-   eo_do(obj, sum = mixin_ab_sum_get(), sum = mixin_ab_sum_get());
+   sum = mixin_ab_sum_get(obj);
+   sum = mixin_ab_sum_get(obj);
 
    Mixin2_Public_Data *pd2 = eo_data_scope_get(obj, MIXIN2_CLASS);
    fail_if(pd2->count != 6);
@@ -37,7 +41,8 @@ main(int argc, char *argv[])
    eo_unref(obj);
 
    obj = eo_add(INHERIT_CLASS, NULL);
-   eo_do(obj, simple_a_set(5), a = simple_a_get());
+   simple_a_set(obj, 5);
+   a = simple_a_get(obj);
    printf("%d\n", a);
    fail_if(a != 5);
 
diff --git a/src/tests/eo/mixin/mixin_mixin.c b/src/tests/eo/mixin/mixin_mixin.c
index d8569d4..427293e 100644
--- a/src/tests/eo/mixin/mixin_mixin.c
+++ b/src/tests/eo/mixin/mixin_mixin.c
@@ -12,7 +12,8 @@ static int
 _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
 {
    int a = 0, b = 0;
-   eo_do(obj, a = simple_a_get(), b = simple_b_get());
+   a = simple_a_get(obj);
+   b = simple_b_get(obj);
    printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
    return a + b;
 }
@@ -20,13 +21,13 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
 static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   return eo_constructor(eo_super(obj, MY_CLASS));
 }
 
 static void
 _destructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_destructor());
+   eo_destructor(eo_super(obj, MY_CLASS));
 }
 
 EAPI EO_FUNC_BODY(mixin_ab_sum_get, int, 0);
diff --git a/src/tests/eo/mixin/mixin_mixin2.c b/src/tests/eo/mixin/mixin_mixin2.c
index 7aff72b..93f30f6 100644
--- a/src/tests/eo/mixin/mixin_mixin2.c
+++ b/src/tests/eo/mixin/mixin_mixin2.c
@@ -18,14 +18,15 @@ _ab_sum_get(Eo *obj, void *class_data)
    Mixin2_Public_Data *pd = (Mixin2_Public_Data *) class_data;
    int sum = 0;
    printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
-   eo_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get());
+   sum = mixin_ab_sum_get(eo_super(obj, MY_CLASS));
 
    ++sum;
    pd->count += 2;
 
      {
         int _a = 0, _b = 0;
-        eo_do(obj, _a = simple_a_get(), _b = simple_b_get());
+        _a = simple_a_get(obj);
+        _b = simple_b_get(obj);
         fail_if(sum != _a + _b + 1);
      }
 
@@ -35,14 +36,14 @@ _ab_sum_get(Eo *obj, void *class_data)
 static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
-   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   obj = eo_constructor(eo_super(obj, MY_CLASS));
    return obj;
 }
 
 static void
 _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_destructor());
+   eo_destructor(eo_super(obj, MY_CLASS));
 }
 
 static Eo_Op_Description op_descs[] = {
diff --git a/src/tests/eo/mixin/mixin_mixin3.c b/src/tests/eo/mixin/mixin_mixin3.c
index d5c2ed7..2a946e4 100644
--- a/src/tests/eo/mixin/mixin_mixin3.c
+++ b/src/tests/eo/mixin/mixin_mixin3.c
@@ -18,14 +18,15 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
    Mixin3_Public_Data *pd = (Mixin3_Public_Data *) class_data;
    int sum = 0;
    printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
-   eo_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get());
+   sum = mixin_ab_sum_get(eo_super(obj, MY_CLASS));
 
    ++sum;
    pd->count += 3;
 
      {
         int _a = 0, _b = 0;
-        eo_do(obj, _a = simple_a_get(), _b = simple_b_get());
+        _a = simple_a_get(obj);
+        _b = simple_b_get(obj);
         fail_if(sum != _a + _b + 2);
      }
 
@@ -35,13 +36,13 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
 static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
-   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   return eo_constructor(eo_super(obj, MY_CLASS));
 }
 
 static void
 _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_destructor());
+   eo_destructor(eo_super(obj, MY_CLASS));
 }
 
 static Eo_Op_Description op_descs[] = {
diff --git a/src/tests/eo/signals/signals_main.c b/src/tests/eo/signals/signals_main.c
index 4fcfaef..5d40331 100644
--- a/src/tests/eo/signals/signals_main.c
+++ b/src/tests/eo/signals/signals_main.c
@@ -23,8 +23,8 @@ _a_changed_cb(void *data, const Eo_Event *event)
 
    cb_count++;
 
-   eo_do(event->obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _null_cb, (void *) 23423));
-   eo_do(event->obj, eo_event_callback_del(EV_A_CHANGED, _null_cb, (void *) 23423));
+   eo_event_callback_priority_add(event->obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _null_cb, (void *) 23423);
+   eo_event_callback_del(event->obj, EV_A_CHANGED, _null_cb, (void *) 23423);
 
    /* Stop as we reached the 3rd one. */
    return (cb_count != 3);
@@ -41,132 +41,132 @@ main(int argc, char *argv[])
    Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS);
 
    /* The order of these two is undetermined. */
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2);
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1);
    /* This will be called afterwards. */
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_DEFAULT, _a_changed_cb, (void *) 3));
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_DEFAULT, _a_changed_cb, (void *) 3);
    /* This will never be called because the previous callback returns NULL. */
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_AFTER, _a_changed_cb, (void *) 4));
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_AFTER, _a_changed_cb, (void *) 4);
 
-   eo_do(obj, simple_a_set(1));
+   simple_a_set(obj, 1);
 
    fail_if(cb_count != 3);
 
-   eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 3));
+   eo_event_callback_del(obj, EV_A_CHANGED, _a_changed_cb, (void *) 3);
    fail_if(pd->cb_count != 3);
 
-   eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 12));
+   eo_event_callback_del(obj, EV_A_CHANGED, _a_changed_cb, (void *) 12);
    fail_if(pd->cb_count != 3);
 
-   eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 4));
+   eo_event_callback_del(obj, EV_A_CHANGED, _a_changed_cb, (void *) 4);
    fail_if(pd->cb_count != 2);
 
-   eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 2));
+   eo_event_callback_del(obj, EV_A_CHANGED, _a_changed_cb, (void *) 2);
    fail_if(pd->cb_count != 1);
 
-   eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 1));
+   eo_event_callback_del(obj, EV_A_CHANGED, _a_changed_cb, (void *) 1);
    fail_if(pd->cb_count != 0);
 
    /* Freeze/thaw. */
    int fcount = 0;
    cb_count = 0;
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1);
    fail_if(pd->cb_count != 1);
 
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 0);
 
-   eo_do(obj, eo_event_freeze());
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   eo_event_freeze(obj);
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 1);
 
-   eo_do(obj, eo_event_freeze());
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   eo_event_freeze(obj);
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 2);
 
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2);
    fail_if(pd->cb_count != 2);
 
-   eo_do(obj, simple_a_set(2));
+   simple_a_set(obj, 2);
    fail_if(cb_count != 0);
-   eo_do(obj, eo_event_thaw());
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   eo_event_thaw(obj);
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 1);
 
-   eo_do(obj, eo_event_thaw());
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   eo_event_thaw(obj);
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 0);
 
-   eo_do(obj, simple_a_set(3));
+   simple_a_set(obj, 3);
    fail_if(cb_count != 2);
 
    cb_count = 0;
-   eo_do(obj, eo_event_thaw());
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   eo_event_thaw(obj);
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 0);
 
-   eo_do(obj, eo_event_freeze());
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   eo_event_freeze(obj);
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 1);
 
-   eo_do(obj, simple_a_set(2));
+   simple_a_set(obj, 2);
    fail_if(cb_count != 0);
-   eo_do(obj, eo_event_thaw());
-   eo_do(obj, fcount = eo_event_freeze_count_get());
+   eo_event_thaw(obj);
+   fcount = eo_event_freeze_count_get(obj);
    fail_if(fcount != 0);
 
-   eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 1));
+   eo_event_callback_del(obj, EV_A_CHANGED, _a_changed_cb, (void *) 1);
    fail_if(pd->cb_count != 1);
-   eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 2));
+   eo_event_callback_del(obj, EV_A_CHANGED, _a_changed_cb, (void *) 2);
    fail_if(pd->cb_count != 0);
 
    /* Global Freeze/thaw. */
    fcount = 0;
    cb_count = 0;
    pd->cb_count = 0;
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1);
    fail_if(pd->cb_count != 1);
 
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 0);
 
-   eo_do(EO_CLASS, eo_event_global_freeze());
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   eo_event_global_freeze(EO_CLASS);
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 1);
 
-   eo_do(EO_CLASS, eo_event_global_freeze());
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   eo_event_global_freeze(EO_CLASS);
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 2);
 
-   eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
+   eo_event_callback_priority_add(obj, EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2);
    fail_if(pd->cb_count != 2);
 
-   eo_do(obj, simple_a_set(2));
+   simple_a_set(obj, 2);
    fail_if(cb_count != 0);
-   eo_do(EO_CLASS, eo_event_global_thaw());
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   eo_event_global_thaw(EO_CLASS);
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 1);
 
-   eo_do(EO_CLASS, eo_event_global_thaw());
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   eo_event_global_thaw(EO_CLASS);
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 0);
 
-   eo_do(obj, simple_a_set(3));
+   simple_a_set(obj, 3);
    fail_if(cb_count != 2);
 
    cb_count = 0;
-   eo_do(EO_CLASS, eo_event_global_thaw());
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   eo_event_global_thaw(EO_CLASS);
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 0);
 
-   eo_do(EO_CLASS, eo_event_global_freeze());
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   eo_event_global_freeze(EO_CLASS);
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 1);
 
-   eo_do(obj, simple_a_set(2));
+   simple_a_set(obj, 2);
    fail_if(cb_count != 0);
-   eo_do(EO_CLASS, eo_event_global_thaw());
-   eo_do(EO_CLASS, fcount = eo_event_global_freeze_count_get());
+   eo_event_global_thaw(EO_CLASS);
+   fcount = eo_event_global_freeze_count_get(EO_CLASS);
    fail_if(fcount != 0);
 
 
diff --git a/src/tests/eo/signals/signals_simple.c b/src/tests/eo/signals/signals_simple.c
index d3145e5..8a70f5f 100644
--- a/src/tests/eo/signals/signals_simple.c
+++ b/src/tests/eo/signals/signals_simple.c
@@ -23,7 +23,7 @@ _a_set(Eo *obj, void *class_data, int a)
    pd->a = a;
    printf("%s %d\n", __func__, pd->a);
 
-   eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a));
+   eo_event_callback_call(obj, EV_A_CHANGED, &pd->a);
 }
 
 Eina_Bool
@@ -59,12 +59,12 @@ _cb_deled(void *data, const Eo_Event *event)
 static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   obj = eo_constructor(eo_super(obj, MY_CLASS));
 
-   eo_do(obj, eo_event_callback_add(EO_BASE_EVENT_CALLBACK_ADD, _cb_added, NULL));
-   eo_do(obj, eo_event_callback_add(EO_BASE_EVENT_CALLBACK_DEL, _cb_deled, NULL));
+   eo_event_callback_add(obj, EO_BASE_EVENT_CALLBACK_ADD, _cb_added, NULL);
+   eo_event_callback_add(obj, EO_BASE_EVENT_CALLBACK_DEL, _cb_deled, NULL);