Add lcov exclude statements

Change-Id: I821116f274289a6862ff923064d582443635cb88
Signed-off-by: Dewal Agarwal <d1.agarwal@samsung.com>

diff --git a/packaging/libaccount-service.spec b/packaging/libaccount-service.spec
index dec2c09af3ad99bb88ede7068aa3b807fcc31667..9d502be17e7e3bd78466dd572f47c7d38e32115a 100644 (file)
--- a/packaging/libaccount-service.spec
+++ b/packaging/libaccount-service.spec
@@ -1,6 +1,6 @@
 Name:       libaccount-service
 Summary:    Account DB library
-Version:    0.4.21
+Version:    0.4.22
 Release:    1
 Group:      Social & Content/API
 License:    Apache-2.0

diff --git a/src/account.c b/src/account.c
index 035e3c6b5fbcf22fc0a974694066173637e6dd67..244fa1a79af3228e274180b4ac0fb074fd714b7b 100644 (file)
--- a/src/account.c
+++ b/src/account.c
@@ -111,10 +111,12 @@ _account_manager_get_instance()
        _INFO("_account_manager_get_instance");
        pthread_mutex_lock(&_account_proxy_instance_mutex);
        if (_acc_mgr != NULL) {
+               /* LCOV_EXCL_START */
                _INFO("instance already created.");
                _account_manager_increase_count();
                pthread_mutex_unlock(&_account_proxy_instance_mutex);
                return _acc_mgr;
+               /* LCOV_EXCL_STOP */
        }
 
 #if !GLIB_CHECK_VERSION(2, 35, 0)
@@ -128,12 +130,14 @@ _account_manager_get_instance()
        _INFO("after g_bus_get_sync");
 
        if (!_connection) {
+               /* LCOV_EXCL_START */
                if (error) {
                        _ERR("Unable to connect to gdbus: %s", error->message);
                        g_clear_error(&error);
                }
                pthread_mutex_unlock(&_account_proxy_instance_mutex);
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
 
        g_clear_error(&error);
@@ -148,6 +152,7 @@ _account_manager_get_instance()
                                                                                 &error);
 
        if (!_acc_mgr) {
+               /* LCOV_EXCL_START */
                if (error) {
                        _ERR("Unable account_manager_proxy_new_sync: %s", error->message);
                        g_clear_error(&error);
@@ -158,6 +163,7 @@ _account_manager_get_instance()
                }
                pthread_mutex_unlock(&_account_proxy_instance_mutex);
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
 
        g_clear_error(&error);
@@ -273,9 +279,11 @@ ACCOUNT_API int account_insert_to_db(account_h account, int *account_db_id)
        return ACCOUNT_ERROR_NONE;
 
 CATCH:
+       /* LCOV_EXCL_START */
        g_clear_error(&error);
        _ERR("account_manager_call_account_add_sync()=[%d]", error_code);
        return error_code;
+       /* LCOV_EXCL_STOP */
 }
 
 ACCOUNT_API int account_delete_from_db_by_id(int account_db_id)
@@ -291,8 +299,10 @@ ACCOUNT_API int account_delete_from_db_by_id(int account_db_id)
 
        AccountManager *acc_mgr = _account_manager_get_instance();
        if (acc_mgr == NULL) {
+               /* LCOV_EXCL_START */
                _ERR("g_bus_get_sync failed");
                return ACCOUNT_ERROR_PERMISSION_DENIED;
+               /* LCOV_EXCL_STOP */
        }
 
        _INFO("2. Before account_manager_call_account_query_account_by_account_id_sync");
@@ -300,11 +310,13 @@ ACCOUNT_API int account_delete_from_db_by_id(int account_db_id)
        bool is_success = account_manager_call_account_query_account_by_account_id_sync(acc_mgr, account_db_id, (int)getuid(), false, &account_serialized_old, NULL, &error);
 
        if (!is_success) {
+               /* LCOV_EXCL_START */
                error_code = _account_get_error_code(is_success, error);
                g_clear_error(&error);
                _ERR("account_manager_call_account_query_account_by_account_id_sync failed [%d]", error_code);
                _account_manager_release_instance();
                return error_code;
+               /* LCOV_EXCL_STOP */
        }
        g_clear_error(&error);
 
@@ -339,8 +351,10 @@ ACCOUNT_API int account_delete_from_db_by_user_name(char *user_name, char *packa
 
        AccountManager *acc_mgr = _account_manager_get_instance();
        if (acc_mgr == NULL) {
+               /* LCOV_EXCL_START */
                _ERR("g_bus_get_sync failed");
                return ACCOUNT_ERROR_PERMISSION_DENIED;
+               /* LCOV_EXCL_STOP */
        }
 
        GVariant *account_list_variant = NULL;
@@ -358,19 +372,23 @@ ACCOUNT_API int account_delete_from_db_by_user_name(char *user_name, char *packa
        g_variant_unref(account_list_variant);
 
        if (account_list == NULL) {
+               /* LCOV_EXCL_START */
                _account_manager_release_instance();
                return ACCOUNT_ERROR_NO_DATA;
+               /* LCOV_EXCL_STOP */
        }
 
        is_success = account_manager_call_account_delete_from_db_by_user_name_sync(acc_mgr, user_name, package_name, (int)getuid(), NULL, &error);
        _account_manager_release_instance();
 
        if (!is_success) {
+               /* LCOV_EXCL_START */
                error_code = _account_get_error_code(is_success, error);
                g_clear_error(&error);
                _ERR("account_manager_call_account_delete_from_db_by_user_name_sync failed [%d]", error_code);
                _account_gslist_account_free(account_list);
                return error_code;
+               /* LCOV_EXCL_STOP */
        }
        g_clear_error(&error);
 
@@ -391,8 +409,10 @@ int _account_delete_from_db_by_package_name(const char *package_name, bool permi
 
        AccountManager *acc_mgr = _account_manager_get_instance();
        if (acc_mgr == NULL) {
+               /* LCOV_EXCL_START */
                _ERR("g_bus_get_sync failed");
                return ACCOUNT_ERROR_PERMISSION_DENIED;
+               /* LCOV_EXCL_STOP */
        }
 /*
        //First get account list of user_name, used for gSSO DB deletion
@@ -451,8 +471,10 @@ ACCOUNT_API int account_update_to_db_by_id(account_h account, int account_id)
 
        AccountManager *acc_mgr = _account_manager_get_instance();
        if (acc_mgr == NULL) {
+               /* LCOV_EXCL_START */
                _ERR("g_bus_get_sync failed");
                return ACCOUNT_ERROR_PERMISSION_DENIED;
+               /* LCOV_EXCL_STOP */
        }
 
        _INFO("2. Before account_manager_call_account_query_account_by_account_id_sync");
@@ -460,11 +482,13 @@ ACCOUNT_API int account_update_to_db_by_id(account_h account, int account_id)
        bool is_success = account_manager_call_account_query_account_by_account_id_sync(acc_mgr, account_id, (int)getuid(), false, &account_serialized_old, NULL, &error);
 
        if (!is_success) {
+               /* LCOV_EXCL_START */
                error_code = _account_get_error_code(is_success, error);
                g_clear_error(&error);
                _account_manager_release_instance();
                _ERR("account_manager_call_account_query_account_by_account_id_sync failed [%d]", error_code);
                return error_code;
+               /* LCOV_EXCL_STOP */
        }
        g_clear_error(&error);
 
@@ -474,10 +498,12 @@ ACCOUNT_API int account_update_to_db_by_id(account_h account, int account_id)
        _account_manager_release_instance();
 
        if (!is_success) {
+               /* LCOV_EXCL_START */
                error_code = _account_get_error_code(is_success, error);
                g_clear_error(&error);
                _ERR("account_manager_call_account_update_to_db_by_id_sync failed [%d]", error_code);
                return error_code;
+               /* LCOV_EXCL_STOP */
        }
        g_clear_error(&error);
 
@@ -577,8 +603,10 @@ ACCOUNT_API int account_update_to_db_by_user_name(account_h account, const char
 
        AccountManager *acc_mgr = _account_manager_get_instance();
        if (acc_mgr == NULL) {
+               /* LCOV_EXCL_START */
                _ERR("g_bus_get_sync failed");
                return ACCOUNT_ERROR_PERMISSION_DENIED;
+               /* LCOV_EXCL_STOP */
        }
 
        GVariant *account_serialized_old = NULL;
@@ -599,10 +627,12 @@ ACCOUNT_API int account_update_to_db_by_user_name(account_h account, const char
        _account_manager_release_instance();
 
        if (!is_success) {
+               /* LCOV_EXCL_START */
                error_code = _account_get_error_code(is_success, error);
                g_clear_error(&error);
                _ERR("account_manager_call_account_update_to_db_by_user_name_sync failed [%d]", error_code);
                return error_code;
+               /* LCOV_EXCL_STOP */
        }
        g_clear_error(&error);
 
@@ -621,8 +651,10 @@ ACCOUNT_API int account_create(account_h *account)
 
        account_s *data = (account_s *)malloc(sizeof(account_s));
        if (data == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("Memory Allocation Failed");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        ACCOUNT_MEMSET(data, 0, sizeof(account_s));
@@ -678,8 +710,10 @@ ACCOUNT_API int account_set_user_name(account_h account, const char *user_name)
        _ACCOUNT_FREE(data->user_name);
        data->user_name = _account_get_text(user_name);
        if (data->user_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -704,8 +738,10 @@ ACCOUNT_API int account_set_display_name(account_h account, const char *display_
        _ACCOUNT_FREE(data->display_name);
        data->display_name = _account_get_text(display_name);
        if (data->display_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -730,8 +766,10 @@ ACCOUNT_API int account_set_email_address(account_h account, const char *email_a
        _ACCOUNT_FREE(data->email_address);
        data->email_address = _account_get_text(email_address);
        if (data->email_address == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -756,8 +794,10 @@ ACCOUNT_API int account_set_icon_path(account_h account, const char *icon_path)
        _ACCOUNT_FREE(data->icon_path);
        data->icon_path = _account_get_text(icon_path);
        if (data->icon_path == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -781,8 +821,10 @@ ACCOUNT_API int account_set_source(account_h account, const char *source)
        _ACCOUNT_FREE(data->source);
        data->source = _account_get_text(source);
        if (data->source == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -807,8 +849,10 @@ ACCOUNT_API int account_set_package_name(account_h account, const char *package_
        _ACCOUNT_FREE(data->package_name);
        data->package_name = _account_get_text(package_name);
        if (data->package_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -832,8 +876,10 @@ ACCOUNT_API int account_set_domain_name(account_h account, const char *domain_na
        _ACCOUNT_FREE(data->domain_name);
        data->domain_name = _account_get_text(domain_name);
        if (data->domain_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -858,8 +904,10 @@ ACCOUNT_API int account_set_access_token(account_h account, const char *access_t
        _ACCOUNT_FREE(data->access_token);
        data->access_token = _account_get_text(access_token);
        if (data->access_token == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -888,8 +936,10 @@ ACCOUNT_API int account_set_user_text(account_h account, int idx, const char *us
        _ACCOUNT_FREE(data->user_data_txt[idx]);
        data->user_data_txt[idx] = _account_get_text(user_txt);
        if (data->user_data_txt[idx] == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -929,8 +979,10 @@ ACCOUNT_API int account_set_custom(account_h account, const char *key, const cha
                        char *new_value = NULL;
                        new_value = _account_get_text(value);
                        if (new_value == NULL) {
+                               /* LCOV_EXCL_START */
                                ACCOUNT_ERROR("OUT OF MEMORY\n");
                                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                               /* LCOV_EXCL_STOP */
                        }
 
                        _ACCOUNT_FREE(custom_data->value);
@@ -943,8 +995,10 @@ ACCOUNT_API int account_set_custom(account_h account, const char *key, const cha
        if (b_is_new) {
                account_custom_s* custom_data = (account_custom_s *)malloc(sizeof(account_custom_s));
                if (custom_data == NULL) {
+                       /* LCOV_EXCL_START */
                        ACCOUNT_ERROR("Memory Allocation Failed");
                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                       /* LCOV_EXCL_STOP */
                }
 
                ACCOUNT_MEMSET(custom_data, 0, sizeof(account_custom_s));
@@ -952,17 +1006,21 @@ ACCOUNT_API int account_set_custom(account_h account, const char *key, const cha
 
                custom_data->key = _account_get_text(key);
                if (custom_data->key == NULL) {
+                       /* LCOV_EXCL_START */
                        ACCOUNT_ERROR("OUT OF MEMORY\n");
                        _ACCOUNT_FREE(custom_data);
                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                       /* LCOV_EXCL_STOP */
                }
 
                custom_data->value = _account_get_text(value);
                if (custom_data->value == NULL) {
+                       /* LCOV_EXCL_START */
                        ACCOUNT_ERROR("OUT OF MEMORY\n");
                        _ACCOUNT_FREE(custom_data->key);
                        _ACCOUNT_FREE(custom_data);
                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                       /* LCOV_EXCL_STOP */
                }
 
                data->custom_list = g_slist_append(data->custom_list, (gpointer)custom_data);
@@ -1066,18 +1124,22 @@ ACCOUNT_API int account_set_capability(account_h account, const char *capability
        if (b_is_new) {
                account_capability_s *cap_data = (account_capability_s *)malloc(sizeof(account_capability_s));
                if (cap_data == NULL) {
+                       /* LCOV_EXCL_START */
                        ACCOUNT_ERROR("Memory Allocation Failed");
                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                       /* LCOV_EXCL_STOP */
                }
 
                ACCOUNT_MEMSET(cap_data, 0, sizeof(account_capability_s));
 
                cap_data->type = _account_get_text(capability_type);
                if (cap_data->type == NULL) {
+                       /* LCOV_EXCL_START */
                        ACCOUNT_ERROR("OUT OF MEMORY\n");
                        _ACCOUNT_FREE(cap_data->type);
                        _ACCOUNT_FREE(cap_data);
                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                       /* LCOV_EXCL_STOP */
                }
 
                cap_data->value = capability_value;
@@ -1102,8 +1164,10 @@ ACCOUNT_API int account_get_user_name(account_h account, char **user_name)
        (*user_name) = NULL;
        *user_name = _account_get_text(data->user_name);
        if (data->user_name != NULL && *user_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -1125,8 +1189,10 @@ ACCOUNT_API int account_get_display_name(account_h account, char **display_name)
 
        *display_name = _account_get_text(data->display_name);
        if (data->display_name != NULL && *display_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
 
@@ -1149,8 +1215,10 @@ ACCOUNT_API int account_get_email_address(account_h account, char **email_addres
 
        *email_address = _account_get_text(data->email_address);
        if (data->email_address != NULL && *email_address == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -1172,8 +1240,10 @@ ACCOUNT_API int  account_get_icon_path(account_h account, char **icon_path)
 
        *icon_path = _account_get_text(data->icon_path);
        if (data->icon_path != NULL && *icon_path == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -1195,8 +1265,10 @@ ACCOUNT_API int account_get_source(account_h account, char **source)
 
        *source = _account_get_text(data->source);
        if (data->source != NULL && *source == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -1218,8 +1290,10 @@ ACCOUNT_API int account_get_package_name(account_h account, char **package_name)
 
        *package_name = _account_get_text(data->package_name);
        if (data->package_name != NULL && *package_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
 
@@ -1242,8 +1316,10 @@ ACCOUNT_API int account_get_domain_name(account_h account, char **domain_name)
 
        *domain_name = _account_get_text(data->domain_name);
        if (data->domain_name != NULL && *domain_name == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -1265,8 +1341,10 @@ ACCOUNT_API int account_get_access_token(account_h account, char **access_token)
 
        *access_token = _account_get_text(data->access_token);
        if (data->access_token != NULL && *access_token == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -1290,8 +1368,10 @@ ACCOUNT_API int account_get_user_text(account_h account, int user_text_index, ch
 
        *text = _account_get_text(data->user_data_txt[user_text_index]);
        if (data->user_data_txt[user_text_index] != NULL && *text == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -1451,8 +1531,10 @@ ACCOUNT_API int account_get_custom(account_h account, const char *key, char **va
                        (*value) = NULL;
                        *value = _account_get_text(custom_data->value);
                        if (custom_data->value != NULL && *value == NULL) {
+                               /* LCOV_EXCL_START */
                                ACCOUNT_ERROR("OUT OF MEMORY\n");
                                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                               /* LCOV_EXCL_STOP */
                        }
 
                        return ACCOUNT_ERROR_NONE;
@@ -1971,8 +2053,10 @@ ACCOUNT_API int account_type_create(account_type_h *account_type)
 
        account_type_s *data = (account_type_s *)malloc(sizeof(account_type_s));
        if (data == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("Memory Allocation Failed");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        ACCOUNT_MEMSET(data, 0, sizeof(account_type_s));
@@ -2028,8 +2112,10 @@ ACCOUNT_INTERNAL_API int account_type_set_app_id(account_type_h account_type, co
        _ACCOUNT_FREE(data->app_id);
        data->app_id = _account_get_text(app_id);
        if (data->app_id == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -2050,8 +2136,10 @@ ACCOUNT_INTERNAL_API int account_type_set_service_provider_id(account_type_h acc
        _ACCOUNT_FREE(data->service_provider_id);
        data->service_provider_id = _account_get_text(service_provider_id);
        if (data->service_provider_id == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -2072,8 +2160,10 @@ ACCOUNT_INTERNAL_API int account_type_set_icon_path(account_type_h account_type,
        _ACCOUNT_FREE(data->icon_path);
        data->icon_path = _account_get_text(icon_path);
        if (data->icon_path == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -2094,8 +2184,10 @@ ACCOUNT_INTERNAL_API int account_type_set_small_icon_path(account_type_h account
        _ACCOUNT_FREE(data->small_icon_path);
        data->small_icon_path = _account_get_text(small_icon_path);
        if (data->small_icon_path == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -2129,25 +2221,31 @@ ACCOUNT_INTERNAL_API int account_type_set_label(account_type_h account_type, con
        account_type_s *data = (account_type_s *)account_type;
        label_s *label_data = (label_s *)malloc(sizeof(label_s));
        if (label_data == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("Memory Allocation Failed");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        ACCOUNT_MEMSET(label_data, 0, sizeof(label_s));
 
        label_data->label = _account_get_text(label);
        if (label_data->label == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                _ACCOUNT_FREE(label_data);
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        label_data->locale = _account_get_text(locale);
        if (label_data->locale == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                _ACCOUNT_FREE(label_data->label);
                _ACCOUNT_FREE(label_data);
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        data->label_list = g_slist_append(data->label_list, (gpointer)label_data);
@@ -2181,17 +2279,21 @@ ACCOUNT_INTERNAL_API int account_type_set_provider_feature(account_type_h accoun
        if (b_is_new) {
                provider_feature_s* feature_data = (provider_feature_s *)malloc(sizeof(provider_feature_s));
                if (feature_data == NULL) {
+                       /* LCOV_EXCL_START */
                        ACCOUNT_ERROR("Memory Allocation Failed");
                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                       /* LCOV_EXCL_STOP */
                }
 
                ACCOUNT_MEMSET(feature_data, 0, sizeof(provider_feature_s));
 
                feature_data->key = _account_get_text(provider_feature);
                if (feature_data->key == NULL) {
+                       /* LCOV_EXCL_START */
                        ACCOUNT_ERROR("OUT OF MEMORY\n");
                        _ACCOUNT_FREE(feature_data);
                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                       /* LCOV_EXCL_STOP */
                }
 
                data->provider_feature_list = g_slist_append(data->provider_feature_list, (gpointer)feature_data);
@@ -2312,8 +2414,10 @@ ACCOUNT_API int account_type_get_app_id(account_type_h account_type, char **app_
        (*app_id) = NULL;
        *app_id = _account_get_text(data->app_id);
        if (*app_id == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -2334,8 +2438,10 @@ ACCOUNT_API int account_type_get_service_provider_id(account_type_h account_type
        (*service_provider_id) = NULL;
        *service_provider_id = _account_get_text(data->service_provider_id);
        if (*service_provider_id == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -2356,8 +2462,10 @@ ACCOUNT_API int account_type_get_icon_path(account_type_h account_type, char **i
        (*icon_path) = NULL;
        *icon_path = _account_get_text(data->icon_path);
        if (*icon_path == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        return ACCOUNT_ERROR_NONE;
@@ -2378,8 +2486,10 @@ ACCOUNT_API int account_type_get_small_icon_path(account_type_h account_type, ch
        (*small_icon_path) = NULL;
        *small_icon_path = _account_get_text(data->small_icon_path);
        if (*small_icon_path == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
 
@@ -2447,8 +2557,10 @@ ACCOUNT_API int account_type_get_label_by_locale(account_type_h account_type, co
                if (!strcmp(locale, label_data->locale)) {
                        *label = _account_get_text(label_data->label);
                        if (*label == NULL) {
+                               /* LCOV_EXCL_START */
                                ACCOUNT_ERROR("OUT OF MEMORY\n");
                                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                               /* LCOV_EXCL_STOP */
                        }
 
                        return ACCOUNT_ERROR_NONE;
@@ -2459,9 +2571,11 @@ ACCOUNT_API int account_type_get_label_by_locale(account_type_h account_type, co
                        if ((char *)(tokens[1]) != NULL) {
                                char *upper_token = g_ascii_strup(tokens[1], strlen(tokens[1]));
                                if (upper_token == NULL) {
+                                       /* LCOV_EXCL_START */
                                        ACCOUNT_ERROR("Memory Allocation Failed");
                                        g_strfreev(tokens);
                                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                                       /* LCOV_EXCL_STOP */
                                }
 
                                if (upper_token != NULL) {
@@ -2479,8 +2593,10 @@ ACCOUNT_API int account_type_get_label_by_locale(account_type_h account_type, co
                                                g_strfreev(tokens);
                                                *label = _account_get_text(label_data->label);
                                                if (*label == NULL) {
+                                                       /* LCOV_EXCL_START */
                                                        ACCOUNT_ERROR("OUT OF MEMORY\n");
                                                        return ACCOUNT_ERROR_OUT_OF_MEMORY;
+                                                       /* LCOV_EXCL_STOP */
                                                }
 
                                                return ACCOUNT_ERROR_NONE;
@@ -2823,8 +2939,10 @@ ACCOUNT_API int account_type_query_label_by_locale(const char *app_id, const cha
        *label = NULL;
        *label = _account_get_text(label_temp);
        if (*label == NULL) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        _INFO("account_type_query_label_by_locale end");
@@ -2992,8 +3110,10 @@ ACCOUNT_API int account_subscribe_create(account_subscribe_h *account_subscribe)
 
        account_subscribe_s *data = (account_subscribe_s *)calloc(1, sizeof(account_subscribe_s));
        if (!data) {
+               /* LCOV_EXCL_START */
                ACCOUNT_ERROR("OUT OF MEMORY\n");
                return ACCOUNT_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        *account_subscribe = (account_subscribe_h)data;