Exclude error code and function from coverage measurement

Signed-off-by: seungha.son <seungha.son@samsung.com>
Change-Id: Icaa92d047a9a3d878ec3a0673bfa95ce5664b3f9

diff --git a/src/badge_internal.c b/src/badge_internal.c
index 3939fdf..f576886 100755 (executable)
--- a/src/badge_internal.c
+++ b/src/badge_internal.c
@@ -86,8 +86,10 @@ char *_badge_get_pkgname_by_pid(void)
        max = _get_max_len();
        pkgname = malloc(max);
        if (!pkgname) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc memory");
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
        memset(pkgname, 0x00, max);
 
@@ -95,23 +97,29 @@ char *_badge_get_pkgname_by_pid(void)
        if (ret != AUL_R_OK) {
                fd = open("/proc/self/cmdline", O_RDONLY);
                if (fd < 0) {
+                       /* LCOV_EXCL_START */
                        free(pkgname);
                        return NULL;
+                       /* LCOV_EXCL_STOP */
                }
 
                ret = read(fd, pkgname, max - 1);
                if (ret <= 0) {
+                       /* LCOV_EXCL_START */
                        close(fd);
                        free(pkgname);
                        return NULL;
+                       /* LCOV_EXCL_STOP */
                }
 
                close(fd);
        }
 
        if (pkgname[0] == '\0') {
+               /* LCOV_EXCL_START */
                free(pkgname);
                return NULL;
+               /* LCOV_EXCL_STOP */
        } else {
                return pkgname;
        }
@@ -137,16 +145,20 @@ static int _badge_check_data_inserted(const char *pkgname,
                         BADGE_TABLE_NAME, pkgname);
 
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc sql query");
                return BADGE_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
        if (sqlret != SQLITE_OK) {
+               /* LCOV_EXCL_START */
                ERR("DB err [%s]", sqlite3_errmsg(db));
                ERR("query[%s]", sqlbuf);
                result = BADGE_ERROR_FROM_DB;
                goto free_and_return;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_step(stmt);
@@ -192,16 +204,20 @@ static int _badge_check_option_inserted(const char *pkgname,
                         BADGE_OPTION_TABLE_NAME, pkgname);
 
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc sql query");
                return BADGE_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
        if (sqlret != SQLITE_OK) {
+               /* LCOV_EXCL_START */
                ERR("DB err [%s]", sqlite3_errmsg(db));
                ERR("query[%s]", sqlbuf);
                result = BADGE_ERROR_FROM_DB;
                goto free_and_return;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_step(stmt);
@@ -267,6 +283,7 @@ static int _badge_check_writable(const char *caller,
        if (g_strcmp0(caller, pkgname) == 0)
                return BADGE_ERROR_NONE;
 
+       /* LCOV_EXCL_START */
        if (_is_same_certinfo(caller, pkgname) == 1)
                return BADGE_ERROR_NONE;
 
@@ -306,6 +323,7 @@ free_and_return:
                sqlite3_finalize(stmt);
 
        return result;
+       /* LCOV_EXCL_STOP */
 }
 
 int _badge_is_existing(const char *pkgname, bool *existing)
@@ -315,16 +333,20 @@ int _badge_is_existing(const char *pkgname, bool *existing)
        int result = BADGE_ERROR_NONE;
 
        if (!pkgname || !existing) {
+               /* LCOV_EXCL_START */
                ERR("pkgname : %s, existing : %p", pkgname, existing);
                return BADGE_ERROR_INVALID_PARAMETER;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%d]", sqlret);
                if (sqlret == SQLITE_PERM)
                        return BADGE_ERROR_PERMISSION_DENIED;
                return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        result = _badge_check_data_inserted(pkgname, db);
@@ -338,7 +360,7 @@ int _badge_is_existing(const char *pkgname, bool *existing)
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -356,24 +378,30 @@ int _badge_get_list(GList **badge_list)
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%d]", sqlret);
                return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q",
                                BADGE_TABLE_NAME);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc sql query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto free_and_return;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
        if (sqlret != SQLITE_OK) {
+               /* LCOV_EXCL_START */
                ERR("fail to sqlite3_prepare_v2 - [%s]", sqlite3_errmsg(db));
                ERR("query[%s]", sqlbuf);
                result = BADGE_ERROR_FROM_DB;
                goto free_and_return;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_step(stmt);
@@ -393,16 +421,20 @@ int _badge_get_list(GList **badge_list)
                if (pkg) {
                        badge_info = (badge_info_s *)calloc(sizeof(badge_info_s), 1);
                        if (badge_info == NULL) {
+                               /* LCOV_EXCL_START */
                                ERR("alloc badge_info fail");
                                result = BADGE_ERROR_OUT_OF_MEMORY;
                                break;
+                               /* LCOV_EXCL_STOP */
                        }
                        badge_info->pkg = strdup(pkg);
                        badge_info->badge_count = badge_count;
                        *badge_list = g_list_append(*badge_list, badge_info);
                } else {
+                       /* LCOV_EXCL_START */
                        ERR("db has invaild data");
                        result = BADGE_ERROR_FROM_DB;
+                       /* LCOV_EXCL_STOP */
                }
        } while (sqlite3_step(stmt) == SQLITE_ROW);
 
@@ -415,7 +447,7 @@ free_and_return:
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -513,15 +545,19 @@ int _badge_insert(badge_h *badge)
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%s][%d]", BADGE_DB_PATH, sqlret);
                return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        /* Check pkgname & id */
        ret = _badge_check_data_inserted(badge->pkgname, db);
        if (ret != BADGE_ERROR_NOT_EXIST) {
+               /* LCOV_EXCL_START */
                result = ret;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlbuf = sqlite3_mprintf("INSERT INTO %q " \
@@ -532,17 +568,21 @@ int _badge_insert(badge_h *badge)
                         BADGE_TABLE_NAME,
                         badge->pkgname, badge->writable_pkgs);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = badge_db_exec(db, sqlbuf, NULL);
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("failed to insert badge[%s], err[%d]",
                                        badge->pkgname, ret);
                result = ret;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        /* inserting badge options */
@@ -559,17 +599,21 @@ int _badge_insert(badge_h *badge)
                        BADGE_OPTION_TABLE_NAME,
                         badge->pkgname);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = badge_db_exec(db, sqlbuf, NULL);
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("failed to insert badge option[%s], err[%d]",
                                        badge->pkgname, sqlret);
                result = ret;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
 return_close_db:
@@ -578,7 +622,7 @@ return_close_db:
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -599,8 +643,10 @@ int _badge_remove(const char *caller, const char *pkgname)
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%d]", sqlret);
                return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = _badge_check_data_inserted(pkgname, db);
@@ -618,9 +664,11 @@ int _badge_remove(const char *caller, const char *pkgname)
        sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q",
                         BADGE_TABLE_NAME, pkgname);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = badge_db_exec(db, sqlbuf, NULL);
@@ -641,17 +689,21 @@ int _badge_remove(const char *caller, const char *pkgname)
        sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q",
                        BADGE_OPTION_TABLE_NAME, pkgname);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = badge_db_exec(db, sqlbuf, NULL);
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("failed to remove badge option[%s], err[%d]",
                                pkgname, ret);
                result = ret;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
 return_close_db:
@@ -660,7 +712,7 @@ return_close_db:
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -682,8 +734,10 @@ int _badge_set_count(const char *caller, const char *pkgname,
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%d]", sqlret);
                return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = _badge_check_data_inserted(pkgname, db);
@@ -702,17 +756,21 @@ int _badge_set_count(const char *caller, const char *pkgname,
                        "WHERE pkgname = %Q",
                         BADGE_TABLE_NAME, count, pkgname);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = badge_db_exec(db, sqlbuf, NULL);
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("failed to set badge[%s] count[%d], err[%d]",
                                pkgname, count, ret);
                result = ret;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
 return_close_db:
@@ -721,7 +779,7 @@ return_close_db:
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -743,11 +801,13 @@ int _badge_get_count(const char *pkgname, unsigned int *count)
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%d]", sqlret);
                if (sqlret == SQLITE_PERM)
                        return BADGE_ERROR_PERMISSION_DENIED;
                else
                        return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = _badge_check_data_inserted(pkgname, db);
@@ -760,17 +820,21 @@ int _badge_get_count(const char *pkgname, unsigned int *count)
                        "WHERE pkgname = %Q",
                         BADGE_TABLE_NAME, pkgname);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
        if (sqlret != SQLITE_OK) {
+               /* LCOV_EXCL_START */
                ERR("fail to prepare %s - [%s]",
                                sqlbuf, sqlite3_errmsg(db));
                result = BADGE_ERROR_FROM_DB;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_step(stmt);
@@ -788,7 +852,7 @@ return_close_db:
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -810,8 +874,10 @@ int _badge_set_display(const char *pkgname,
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%d]", sqlret);
                return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = _badge_check_data_inserted(pkgname, db);
@@ -826,17 +892,21 @@ int _badge_set_display(const char *pkgname,
                                "WHERE pkgname = %Q",
                                BADGE_OPTION_TABLE_NAME, is_display, pkgname);
                if (!sqlbuf) {
+                       /* LCOV_EXCL_START */
                        ERR("fail to alloc query");
                        result = BADGE_ERROR_OUT_OF_MEMORY;
                        goto return_close_db;
+                       /* LCOV_EXCL_STOP */
                }
 
                ret = badge_db_exec(db, sqlbuf, NULL);
                if (ret != BADGE_ERROR_NONE) {
+                       /* LCOV_EXCL_START */
                        ERR("failed to set badge[%s] option[%d], err[%d]",
                                        pkgname, is_display, ret);
                        result = ret;
                        goto return_close_db;
+                       /* LCOV_EXCL_STOP */
                }
 
        } else if (ret == BADGE_ERROR_NOT_EXIST) {
@@ -848,17 +918,21 @@ int _badge_set_display(const char *pkgname,
                                BADGE_OPTION_TABLE_NAME,
                                pkgname, is_display);
                if (!sqlbuf) {
+                       /* LCOV_EXCL_START */
                        ERR("fail to alloc query");
                        result = BADGE_ERROR_OUT_OF_MEMORY;
                        goto return_close_db;
+                       /* LCOV_EXCL_STOP */
                }
 
                ret = badge_db_exec(db, sqlbuf, NULL);
                if (ret != BADGE_ERROR_NONE) {
+                       /* LCOV_EXCL_START */
                        ERR("failed to set badge[%s] option[%d], err[%d]",
                                        pkgname, is_display, ret);
                        result = ret;
                        goto return_close_db;
+                       /* LCOV_EXCL_STOP */
                }
        } else {
                result = ret;
@@ -871,7 +945,7 @@ return_close_db:
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -893,11 +967,13 @@ int _badge_get_display(const char *pkgname, unsigned int *is_display)
 
        sqlret = db_util_open(BADGE_DB_PATH, &db, 0);
        if (sqlret != SQLITE_OK || !db) {
+               /* LCOV_EXCL_START */
                ERR("fail to db_util_open - [%d]", sqlret);
                if (sqlret == SQLITE_PERM)
                        return BADGE_ERROR_PERMISSION_DENIED;
                else
                        return BADGE_ERROR_FROM_DB;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = _badge_check_option_inserted(pkgname, db);
@@ -913,17 +989,21 @@ int _badge_get_display(const char *pkgname, unsigned int *is_display)
                        "WHERE pkgname = %Q",
                        BADGE_OPTION_TABLE_NAME, pkgname);
        if (!sqlbuf) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc query");
                result = BADGE_ERROR_OUT_OF_MEMORY;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL);
        if (sqlret != SQLITE_OK) {
+               /* LCOV_EXCL_START */
                ERR("fail to prepare %s - [%s]",
                                sqlbuf, sqlite3_errmsg(db));
                result = BADGE_ERROR_FROM_DB;
                goto return_close_db;
+               /* LCOV_EXCL_STOP */
        }
 
        sqlret = sqlite3_step(stmt);
@@ -941,7 +1021,7 @@ return_close_db:
 
        sqlret = db_util_close(db);
        if (sqlret != SQLITE_OK)
-               WARN("fail to db_util_close - [%d]", sqlret);
+               WARN("fail to db_util_close - [%d]", sqlret); /* LCOV_EXCL_LINE */
 
        return result;
 }
@@ -1022,9 +1102,11 @@ int _badge_register_changed_cb(badge_change_cb callback, void *data)
 
        ret = _badge_changed_monitor_init();
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("badge_ipc_monitor_init err : %d", ret);
                _badge_unregister_changed_cb(callback);
                return ret;
+               /* LCOV_EXCL_STOP */
        }
        return BADGE_ERROR_NONE;
 }
@@ -1151,11 +1233,13 @@ char *_badge_pkgs_new(int *err, const char *pkg1, ...)
 
        result = g_new0(char, length + 1); /* 1 for null terminate */
        if (!result) {
+               /* LCOV_EXCL_START */
                ERR("fail to alloc memory");
                if (err)
                        *err = BADGE_ERROR_OUT_OF_MEMORY;
                free(caller_pkgname);
                return NULL;
+               /* LCOV_EXCL_STOP */
        }
 
        ptr = result;

diff --git a/src/badge_ipc.c b/src/badge_ipc.c
index 76dfc91..551aa91 100755 (executable)
--- a/src/badge_ipc.c
+++ b/src/badge_ipc.c
@@ -80,18 +80,22 @@ int badge_ipc_is_master_ready(void)
                        &err);
 
        if (err || (result == NULL)) {
+               /* LCOV_EXCL_START */
                if (err) {
                        ERR("No reply. error = %s", err->message);
                        g_error_free(err);
                }
                is_master_started = 0;
+               /* LCOV_EXCL_STOP */
        } else {
                g_variant_get(result, "(b)", &name_exist);
 
                if (!name_exist) {
+                       /* LCOV_EXCL_START */
                        ERR("Name not exist %s", PROVIDER_BUS_NAME);
                        ERR("the master has been stopped");
                        is_master_started = 0;
+                       /* LCOV_EXCL_STOP */
                } else {
                        DBG("the master has been started");
                        is_master_started = 1;
@@ -178,6 +182,7 @@ int badge_ipc_del_deferred_task(
        return BADGE_ERROR_INVALID_PARAMETER;
 }
 
+/* LCOV_EXCL_START */
 static void _do_deferred_task(void)
 {
        task_list *list_do;
@@ -202,10 +207,12 @@ static void _do_deferred_task(void)
                list_do = list_temp;
        }
 }
+/* LCOV_EXCL_STOP */
 
 /*
  * dbus handler implementation
  */
+/* LCOV_EXCL_START */
 static void _insert_badge_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
@@ -213,7 +220,9 @@ static void _insert_badge_notify(GVariant *parameters)
        g_variant_get(parameters, "(&s)", &pkgname);
        badge_changed_cb_call(BADGE_ACTION_CREATE, pkgname, 0);
 }
+/* LCOV_EXCL_STOP */
 
+/* LCOV_EXCL_START */
 static void _delete_badge_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
@@ -221,7 +230,9 @@ static void _delete_badge_notify(GVariant *parameters)
        g_variant_get(parameters, "(&s)", &pkgname);
        badge_changed_cb_call(BADGE_ACTION_REMOVE, pkgname, 0);
 }
+/* LCOV_EXCL_STOP */
 
+/* LCOV_EXCL_START */
 static void _set_badge_count_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
@@ -230,7 +241,9 @@ static void _set_badge_count_notify(GVariant *parameters)
        g_variant_get(parameters, "(&si)", &pkgname, &count);
        badge_changed_cb_call(BADGE_ACTION_UPDATE, pkgname, count);
 }
+/* LCOV_EXCL_STOP */
 
+/* LCOV_EXCL_START */
 static void _set_disp_option_notify(GVariant *parameters)
 {
        char *pkgname = NULL;
@@ -239,7 +252,9 @@ static void _set_disp_option_notify(GVariant *parameters)
        g_variant_get(parameters, "(&si)", &pkgname, &is_display);
        badge_changed_cb_call(BADGE_ACTION_CHANGED_DISPLAY, pkgname, is_display);
 }
+/* LCOV_EXCL_STOP */
 
+/* LCOV_EXCL_START */
 static void _handle_badge_notify(GDBusConnection *connection,
                const gchar     *sender_name,
                const gchar     *object_path,
@@ -258,6 +273,7 @@ static void _handle_badge_notify(GDBusConnection *connection,
        else if (g_strcmp0(signal_name, "set_disp_option_notify") == 0)
                _set_disp_option_notify(parameters);
 }
+/* LCOV_EXCL_STOP */
 
 static int _dbus_init(void)
 {
@@ -266,10 +282,12 @@ static int _dbus_init(void)
        if (_gdbus_conn == NULL) {
                _gdbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
                if (_gdbus_conn == NULL) {
+                       /* LCOV_EXCL_START */
                        if (error != NULL) {
                                ERR("Failed to get dbus [%s]", error->message);
                                g_error_free(error);
                        }
+                       /* LCOV_EXCL_STOP */
                        return BADGE_ERROR_IO_ERROR;
                }
                badge_error_quark();
@@ -298,8 +316,10 @@ static int _dbus_signal_init()
 
                DBG("subscribe id : %d", id);
                if (id == 0) {
+                       /* LCOV_EXCL_START */
                        ret = BADGE_ERROR_IO_ERROR;
                        ERR("Failed to _register_noti_dbus_interface");
+                       /* LCOV_EXCL_STOP */
                } else {
                        monitor_id = id;
                }
@@ -323,10 +343,12 @@ static int _send_sync_badge(GVariant *body, GDBusMessage **reply, char *cmd)
                        PROVIDER_BADGE_INTERFACE_NAME,
                        cmd);
        if (!msg) {
+               /* LCOV_EXCL_START */
                ERR("Can't allocate new method call");
                if (body)
                        g_variant_unref(body);
                return BADGE_ERROR_OUT_OF_MEMORY;
+               /* LCOV_EXCL_STOP */
        }
 
        if (body != NULL)
@@ -344,6 +366,7 @@ static int _send_sync_badge(GVariant *body, GDBusMessage **reply, char *cmd)
        g_object_unref(msg);
 
        if (!*reply) {
+               /* LCOV_EXCL_START */
                ret = BADGE_ERROR_SERVICE_NOT_READY;
                if (err != NULL) {
                        ERR("No reply. cmd = %s,  error = %s", cmd, err->message);
@@ -352,6 +375,7 @@ static int _send_sync_badge(GVariant *body, GDBusMessage **reply, char *cmd)
                        g_error_free(err);
                }
                return ret;
+               /* LCOV_EXCL_STOP */
        }
 
        if (g_dbus_message_to_gerror(*reply, &err)) {
@@ -389,6 +413,7 @@ static int _ipc_monitor_register(void)
        return  _send_service_register();
 }
 
+/* LCOV_EXCL_START */
 static void _on_name_appeared(GDBusConnection *connection,
                const gchar     *name,
                const gchar     *name_owner,
@@ -400,7 +425,9 @@ static void _on_name_appeared(GDBusConnection *connection,
 
        _do_deferred_task();
 }
+/* LCOV_EXCL_STOP */
 
+/* LCOV_EXCL_START */
 static void _on_name_vanished(GDBusConnection *connection,
                const gchar     *name,
                gpointer         user_data)
@@ -408,6 +435,7 @@ static void _on_name_vanished(GDBusConnection *connection,
        DBG("name vanished : %s", name);
        is_master_started = 0;
 }
+/* LCOV_EXCL_STOP */
 
 int badge_ipc_monitor_init(void)
 {
@@ -416,20 +444,26 @@ int badge_ipc_monitor_init(void)
 
        ret = _dbus_init();
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("Can't init dbus %d", ret);
                return ret;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = _dbus_signal_init();
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("Can't init dbus signal %d", ret);
                return ret;
+               /* LCOV_EXCL_STOP */
        }
 
        ret = _ipc_monitor_register();
        if (ret != BADGE_ERROR_NONE) {
+               /* LCOV_EXCL_START */
                ERR("Can't init ipc_monitor_register %d", ret);
                return ret;
+               /* LCOV_EXCL_STOP */
        }
 
        if (provider_monitor_id == 0) {
@@ -443,10 +477,12 @@ int badge_ipc_monitor_init(void)
                                NULL);
 
                if (provider_monitor_id == 0) {
+                       /* LCOV_EXCL_START */
                        ERR("watch on name fail");
                        g_dbus_connection_signal_unsubscribe(_gdbus_conn, monitor_id);
                        monitor_id = 0;
                        return BADGE_ERROR_IO_ERROR;
+                       /* LCOV_EXCL_STOP */
                }
        }
 

diff --git a/src/badge_setting.c b/src/badge_setting.c
index 39969e5..2e9de36 100755 (executable)
--- a/src/badge_setting.c
+++ b/src/badge_setting.c
@@ -237,6 +237,7 @@ EXPORT_API int badge_setting_db_get(const char *pkgname, const char *property, c
                goto return_close_db;
        }
 
+       /* LCOV_EXCL_START */
        sqlbuf = sqlite3_mprintf("SELECT %q FROM %q " \
                        "WHERE appid = %Q",
                        column, SETTING_DB_TABLE, pkgname);
@@ -269,6 +270,7 @@ EXPORT_API int badge_setting_db_get(const char *pkgname, const char *property, c
                        goto return_close_db;
                }
        }
+       /* LCOV_EXCL_STOP */
 
 return_close_db:
        if (sqlbuf)