7 files changed, 107 insertions, 130 deletions

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);