Improves code coverage and change package name for unittest

Change-Id: Id5d84160e4663487382d1d43e318c0e657d345ea
Signed-off-by: Inkyun Kil <inkyun.kil@samsung.com>

diff --git a/packaging/data-control.spec b/packaging/data-control.spec
index 50999427ab8d51b48f5b298e851e1dbebc58d0e1..991296efc992552a5f121c4d5c42f3fda9c2910b 100644 (file)
--- a/packaging/data-control.spec
+++ b/packaging/data-control.spec
@@ -40,14 +40,14 @@ Requires: %{name} = %{version}-%{release}
 Data Control library (DEV)
 
 #################################################
-# data_control_unittests
+# data-control-unittests
 #################################################
-%package -n data_control_unittests
+%package -n data-control-unittests
 Summary:    GTest for Data Control API
 Group:      Development/Libraries
 Requires:   %{name}
 
-%description -n data_control_unittests
+%description -n data-control-unittests
 GTest for data-control API
 
 #################################################
@@ -146,9 +146,9 @@ install -m 0755 run-unittest.sh %{buildroot}%{_bindir}/tizen-unittests/%{name}/
 %{_libdir}/lib%{name}.so
 
 #################################################
-# data_control_unittests
+# data-control-unittests
 #################################################
-%files -n data_control_unittests
+%files -n data-control-unittests
 %{_bindir}/data_control_unittests
 %{_bindir}/tizen-unittests/%{name}/run-unittest.sh
 

diff --git a/src/data_control_internal.c b/src/data_control_internal.c
index c9560e084903ef22b68baaf4a83699bef348b044..5a7169bddeab96d08ee3338855360489ca5efba1 100644 (file)
--- a/src/data_control_internal.c
+++ b/src/data_control_internal.c
@@ -173,9 +173,11 @@ static struct datacontrol_cert_info* __insert_hash(GHashTable *hash, const char
 
        hash_key = strdup(key);
        if (hash_key == NULL) {
+/* LCOV_EXCL_START */
                free(cert_info);
                _LOGE("out of memory.");
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        g_hash_table_insert(hash, hash_key, cert_info);
@@ -257,6 +259,7 @@ static void __remove_request_info(int request_id, __response_cb_s *dc)
        }
 }
 
+/* LCOV_EXCL_START */
 static gboolean __find_bound_cb_func(gpointer key, gpointer value,
                gpointer user_data)
 {
@@ -270,6 +273,7 @@ static gboolean __find_bound_cb_func(gpointer key, gpointer value,
 
        return FALSE;
 }
+/* LCOV_EXCL_STOP */
 
 static char **__map_get_value_list(int fd, int *value_count)
 {
@@ -1745,30 +1749,38 @@ int __create_response_s(data_control_h provider, char *app_id,
 
        _dc_temp = (__response_cb_s *)calloc(1, sizeof(__response_cb_s));
        if (!_dc_temp) {
+/* LCOV_EXCL_START */
                _LOGE("unable to create a temporary data control");
                ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                goto EXCEPTION;
+/* LCOV_EXCL_STOP */
        }
 
        _dc_temp->provider_id = strdup(provider->provider_id);
        if (!_dc_temp->provider_id) {
+/* LCOV_EXCL_START */
                _LOGE("unable to assign provider_id to data control: %d", errno);
                ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                goto EXCEPTION;
+/* LCOV_EXCL_STOP */
        }
 
        _dc_temp->data_id = strdup(provider->data_id);
        if (!_dc_temp->data_id) {
+/* LCOV_EXCL_START */
                _LOGE("unable to assign data_id to data control: %d", errno);
                ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                goto EXCEPTION;
+/* LCOV_EXCL_STOP */
        }
 
        _dc_temp->app_id = strdup(app_id);
        if (!_dc_temp->app_id) {
+/* LCOV_EXCL_START */
                _LOGE("unable to assign app_id to data control: %d", errno);
                ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                goto EXCEPTION;
+/* LCOV_EXCL_STOP */
        }
 
        *response_cb_s = _dc_temp;
@@ -2350,8 +2362,10 @@ int _set_provider_id(data_control_h provider, const char *provider_id)
 
        dup_provider_id = strdup(provider_id);
        if (dup_provider_id == NULL) {
+/* LCOV_EXCL_START */
                _LOGE("Out of memory");
                return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
        }
 
        if (provider->provider_id != NULL)
@@ -2372,8 +2386,10 @@ int _get_provider_id(data_control_h provider, char **provider_id)
        if (provider->provider_id != NULL) {
                dup_provider_id = strdup(provider->provider_id);
                if (dup_provider_id == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("Out of memory");
                        return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
                }
 
                *provider_id = dup_provider_id;
@@ -2394,8 +2410,10 @@ int _set_data_id(data_control_h provider, const char *data_id)
 
        dup_data_id = strdup(data_id);
        if (dup_data_id == NULL) {
+/* LCOV_EXCL_START */
                _LOGE("Out of memory");
                return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
        }
 
        if (provider->data_id != NULL)
@@ -2416,8 +2434,10 @@ int _get_data_id(data_control_h provider, char **data_id)
        if (provider->data_id != NULL) {
                dup_data_id = strdup(provider->data_id);
                if (dup_data_id == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("Out of memory");
                        return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
                }
 
                *data_id = dup_data_id;

diff --git a/src/data_control_provider.c b/src/data_control_provider.c
index 7dd6799d946e32a70d0cb833ef53396a9df34f5c..208a4915594c223ad303efa8b87b7b0681dbc2d4 100644 (file)
--- a/src/data_control_provider.c
+++ b/src/data_control_provider.c
@@ -233,7 +233,6 @@ static void __free_consumer_info_by_name(const gchar *name)
 
        _LOGI("__free_consumer_info done");
 }
-/* LCOV_EXCL_STOP */
 
 static int __check_consumer_cert(const char *provider_id,
                const char *consumer_appid,
@@ -252,6 +251,7 @@ static int __check_consumer_cert(const char *provider_id,
 
        return _check_cert(provider_id, is_map, consumer_appid);
 }
+/* LCOV_EXCL_STOP */
 
 int __datacontrol_get_data_changed_filter_callback_id(void)
 {
@@ -299,8 +299,10 @@ static bundle *__get_bundle_data_from_fd(int fd)
        if (len > 0 && len < MAX_REQUEST_ARGUMENT_SIZE) {
                buf = (char *)calloc(len, sizeof(char));
                if (buf == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("calloc fail");
                        return NULL;
+/* LCOV_EXCL_STOP */
                }
                ret = _read_socket(fd, buf, len, &bytes_read);
                if (ret != DATA_CONTROL_ERROR_NONE) {
@@ -510,11 +512,11 @@ static int __init_changed_noti_consumer_list()
                __noti_consumer_app_list =
                        g_list_append(__noti_consumer_app_list, consumer_info);
        }
-/* LCOV_EXCL_STOP */
        sqlite3_reset(stmt);
        sqlite3_finalize(stmt);
 
        return ret;
+/* LCOV_EXCL_STOP */
 }
 
 static int __delete_consumer_list_db_info(char *unique_id)
@@ -666,29 +668,37 @@ static int __set_consumer_app_list(char *caller, char *object_path,
                consumer_info = (datacontrol_consumer_info *)
                        calloc(1, sizeof(datacontrol_consumer_info));
                if (consumer_info == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("out of memory.");
                        return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
                }
 
                consumer_info->appid = strdup(caller);
                if (consumer_info->appid == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("out of memory.");
                        ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                        goto EXCEPTION;
+/* LCOV_EXCL_STOP */
                }
 
                consumer_info->object_path = strdup(object_path);
                if (consumer_info->object_path == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("out of memory.");
                        ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                        goto EXCEPTION;
+/* LCOV_EXCL_STOP */
                }
 
                consumer_info->unique_id = strdup(unique_id);
                if (consumer_info->unique_id == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("out of memory.");
                        ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                        goto EXCEPTION;
+/* LCOV_EXCL_STOP */
                }
 
                ret = _create_data_control_h(&provider);
@@ -701,16 +711,20 @@ static int __set_consumer_app_list(char *caller, char *object_path,
 
                provider->provider_id = strdup(provider_id);
                if (provider->provider_id == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("out of memory.");
                        ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                        goto EXCEPTION;
+/* LCOV_EXCL_STOP */
                }
 
                provider->data_id = strdup(data_id);
                if (provider->data_id == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("out of memory.");
                        ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                        goto EXCEPTION;
+/* LCOV_EXCL_STOP */
                }
 
                consumer_info->monitor_id = g_bus_watch_name_on_connection(
@@ -1309,9 +1323,11 @@ int __datacontrol_send_async(int sockfd, bundle *kb,
        /* encoded bundle + encoded bundle len */
        buf = (char *)calloc(datalen + 4, sizeof(char));
        if (buf == NULL) {
+/* LCOV_EXCL_START */
                _LOGE("buf calloc error");
                ret = DATA_CONTROL_ERROR_OUT_OF_MEMORY;
                goto out;
+/* LCOV_EXCL_STOP */
        }
        memcpy(buf, &datalen, sizeof(datalen));
        memcpy(buf + sizeof(datalen), kb_data, datalen);
@@ -2006,8 +2022,10 @@ int __datacontrol_handler_cb(bundle *b, int request_id, void *data)
 
                dup_caller = strdup(caller);
                if (dup_caller == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("Out of memory");
                        return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
                }
                socket_info = g_hash_table_lookup(__socket_pair_hash, dup_caller);
 
@@ -2184,8 +2202,10 @@ EXPORT_API int data_control_provider_get_client_appid(
 
        dup_appid = strdup(caller);
        if (dup_appid == NULL) {
+/* LCOV_EXCL_START */
                _LOGE("Fail to alloc for appid");
                return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
        }
 
        *appid = dup_appid;
@@ -2407,15 +2427,19 @@ static void bundle_foreach_cb(const char *key, const int type,
 
        pair->keys[index] = strdup(key);
        if (pair->keys[index] == NULL) {
+/* LCOV_EXCL_START */
                _LOGE("Out of memory");
                return;
+/* LCOV_EXCL_STOP */
        }
 
        bundle_keyval_get_basic_val((bundle_keyval_t *)kv, (void **)&value, &value_len);
        pair->vals[index] = strdup(value);
        if (pair->vals[index] == NULL) {
+/* LCOV_EXCL_START */
                _LOGE("Out of memory");
                return;
+/* LCOV_EXCL_STOP */
        }
 
        pair->length += strlen(key) + value_len;
@@ -2440,25 +2464,31 @@ EXPORT_API char *data_control_provider_create_insert_statement(
 
        key_val_pair *cols = (key_val_pair *) calloc(1, sizeof(key_val_pair));
        if (cols == NULL) {
+/* LCOV_EXCL_START */
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        cols->no_of_elements = 0;
        cols->length = 0;
        cols->keys = (char **) calloc(row_count, sizeof(char *));
        if (cols->keys == NULL) {
+/* LCOV_EXCL_START */
                free(cols);
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        cols->vals = (char **) calloc(row_count, sizeof(char *));
        if (cols->vals == NULL) {
+/* LCOV_EXCL_START */
                free(cols->keys);
                free(cols);
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        index = 0;
@@ -2471,11 +2501,13 @@ EXPORT_API char *data_control_provider_create_insert_statement(
 
        sql = (char *)calloc(sql_len, sizeof(char));
        if (sql == NULL) {
+/* LCOV_EXCL_START */
                free(cols->keys);
                free(cols->vals);
                free(cols);
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        snprintf(sql, sql_len, "INSERT INTO %s (", provider->data_id);
@@ -2528,8 +2560,10 @@ EXPORT_API char *data_control_provider_create_delete_statement(
 
        sql = (char *)calloc(sql_len, sizeof(char));
        if (sql == NULL) {
+/* LCOV_EXCL_START */
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        snprintf(sql, sql_len, "DELETE FROM %s", provider->data_id);
@@ -2559,24 +2593,30 @@ EXPORT_API char *data_control_provider_create_update_statement(
 
        key_val_pair *cols = (key_val_pair *) calloc(1, sizeof(key_val_pair));
        if (cols == NULL) {
+/* LCOV_EXCL_START */
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        cols->no_of_elements = 0;
        cols->length = 0;
        cols->keys = (char **)calloc(row_count, sizeof(char *));
        if (cols->keys == NULL) {
+/* LCOV_EXCL_START */
                free(cols);
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
        cols->vals = (char **)calloc(row_count, sizeof(char *));
        if (cols->vals == NULL) {
+/* LCOV_EXCL_START */
                free(cols->keys);
                free(cols);
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        index = 0;
@@ -2590,11 +2630,13 @@ EXPORT_API char *data_control_provider_create_update_statement(
 
        sql = (char *) calloc(sql_len, sizeof(char));
        if (sql == NULL) {
+/* LCOV_EXCL_START */
                free(cols->keys);
                free(cols->vals);
                free(cols);
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        snprintf(sql, sql_len, "UPDATE %s SET ", provider->data_id);
@@ -2663,8 +2705,10 @@ EXPORT_API char *data_control_provider_create_select_statement(
 
        sql = (char *) calloc(sql_len, sizeof(char));
        if (sql == NULL) {
+/* LCOV_EXCL_START */
                set_last_result(DATA_CONTROL_ERROR_OUT_OF_MEMORY);
                return NULL;
+/* LCOV_EXCL_STOP */
        }
 
        strncpy(sql, "SELECT ", sql_len);
@@ -2913,8 +2957,10 @@ EXPORT_API int data_control_provider_add_data_change_consumer_filter_cb(
        changed_noti_consumer_filter_info_s *filter_info =
                (changed_noti_consumer_filter_info_s *)calloc(1, sizeof(changed_noti_consumer_filter_info_s));
        if (filter_info == NULL) {
+/* LCOV_EXCL_START */
                _LOGE("out of memory.");
                return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
        }
 
        *callback_id = __datacontrol_get_data_changed_filter_callback_id();
@@ -2977,6 +3023,7 @@ EXPORT_API int data_control_provider_send_data_change_noti(
                        g_list_length(__noti_consumer_app_list), type);
        consumer_iter = g_list_first(__noti_consumer_app_list);
        for (; consumer_iter != NULL; consumer_iter = consumer_iter->next) {
+/* LCOV_EXCL_START */
                consumer_info = (datacontrol_consumer_info *)consumer_iter->data;
                if (__check_consumer_cert(provider->provider_id,
                                        consumer_info->appid,
@@ -2992,6 +3039,7 @@ EXPORT_API int data_control_provider_send_data_change_noti(
                        _LOGE("__send_signal_to_consumer fail : %d", retval);
                        break;
                }
+/* LCOV_EXCL_STOP */
        }
        return retval;
 }
@@ -3069,27 +3117,33 @@ EXPORT_API int data_control_provider_foreach_data_change_consumer(
 
        ret = sqlite3_prepare_v2(__provider_db, query, -1, &stmt, NULL);
        if (ret != SQLITE_OK) {
+/* LCOV_EXCL_START */
                _LOGE("prepare stmt fail");
                ret = DATA_CONTROL_ERROR_IO_ERROR;
                goto out;
+/* LCOV_EXCL_STOP */
        }
 
        ret = sqlite3_bind_text(stmt, 1, provider->provider_id, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
+/* LCOV_EXCL_START */
                _LOGE("bind provider id fail: %s", sqlite3_errmsg(__provider_db));
                ret = DATA_CONTROL_ERROR_IO_ERROR;
                goto out;
+/* LCOV_EXCL_STOP */
        }
 
        ret = sqlite3_bind_text(stmt, 2, provider->data_id, -1, SQLITE_TRANSIENT);
        if (ret != SQLITE_OK) {
+/* LCOV_EXCL_START */
                _LOGE("bind data id fail: %s", sqlite3_errmsg(__provider_db));
                ret = DATA_CONTROL_ERROR_IO_ERROR;
                goto out;
+/* LCOV_EXCL_STOP */
        }
 
        while (SQLITE_ROW == sqlite3_step(stmt)) {
-
+/* LCOV_EXCL_START */
                app_id = (char *)sqlite3_column_text(stmt, 0);
                if (!app_id) {
                        _LOGE("Failed to get package name\n");
@@ -3102,12 +3156,15 @@ EXPORT_API int data_control_provider_foreach_data_change_consumer(
                                app_id, unique_id, callback_result);
                if (!callback_result)
                        break;
+/* LCOV_EXCL_STOP */
        }
 out:
        if (stmt) {
+/* LCOV_EXCL_START */
                sqlite3_reset(stmt);
                sqlite3_clear_bindings(stmt);
                sqlite3_finalize(stmt);
+/* LCOV_EXCL_STOP */
        }
 
        return ret;

diff --git a/src/data_control_sql_cursor.c b/src/data_control_sql_cursor.c
index cb350672c6f2bcc4ced4055b3848bd209de96386..0e293b3e6f3256c2403039f2c7ac76a5fa5984fa 100644 (file)
--- a/src/data_control_sql_cursor.c
+++ b/src/data_control_sql_cursor.c
@@ -97,6 +97,7 @@ EXPORT_API int data_control_sql_step_last(result_set_cursor cursor)
                __cursor->resultset_current_row_count =
                        __cursor->resultset_row_count - 1;
        } else {
+/* LCOV_EXCL_START */
                /* Move till last row offset. */
                for (i = (__cursor->resultset_current_row_count + 1);
                                i < __cursor->resultset_row_count;
@@ -106,6 +107,7 @@ EXPORT_API int data_control_sql_step_last(result_set_cursor cursor)
                        if (ret != DATA_CONTROL_ERROR_NONE)
                                return ret;
                }
+/* LCOV_EXCL_STOP */
        }
 
        return DATA_CONTROL_ERROR_NONE;
@@ -405,40 +407,50 @@ EXPORT_API int data_control_sql_get_blob_data(result_set_cursor cursor,
 
        ret = lseek(fd, __cursor->resultset_current_offset, SEEK_SET);
        if (ret < 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to seek in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        /* move to column index */
        for (i = 0; i < column_index; i++) {
                ret = read(fd, &type, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
+/* LCOV_EXCL_STOP */
                        return DATA_CONTROL_ERROR_IO_ERROR;
                }
 
                ret = read(fd, &size, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
+/* LCOV_EXCL_STOP */
                        return DATA_CONTROL_ERROR_IO_ERROR;
                }
 
                ret = lseek(fd, size, SEEK_CUR);
                if (ret < 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to seek in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
        }
 
        ret = read(fd, &type, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        if (type != (int)DATA_CONTROL_SQL_COLUMN_TYPE_BLOB) {
@@ -448,9 +460,11 @@ EXPORT_API int data_control_sql_get_blob_data(result_set_cursor cursor,
 
        ret = read(fd, &size, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read size in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        if (size > data_size) {
@@ -461,17 +475,21 @@ EXPORT_API int data_control_sql_get_blob_data(result_set_cursor cursor,
        if (size > 0 && size < MAX_REQUEST_ARGUMENT_SIZE) {
                data = (char *)malloc((size + 1) * (sizeof(char)));
                if (data == NULL) {
+/* LCOV_EXCL_START */
                        _LOGE("Out of memory");
                        return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
                }
                memset(data, 0, size + 1);
 
                ret = read(fd, data, size);
                if (ret < size) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        free(data);
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
 
                memcpy(buffer, data, size + 1);
@@ -518,40 +536,50 @@ EXPORT_API int data_control_sql_get_int64_data(result_set_cursor cursor,
        fd = __cursor->resultset_fd;
        ret = lseek(fd, __cursor->resultset_current_offset, SEEK_SET);
        if (ret < 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to seek in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        /* move to column index */
        for (i = 0; i < column_index; i++) {
                ret = read(fd, &type, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
 
                ret = read(fd, &size, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
 
                ret = lseek(fd, size, SEEK_CUR);
                if (ret < 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to seek in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
        }
 
        ret = read(fd, &type, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        if (type != (int)DATA_CONTROL_SQL_COLUMN_TYPE_INT64) {
@@ -561,16 +589,20 @@ EXPORT_API int data_control_sql_get_int64_data(result_set_cursor cursor,
 
        ret = read(fd, &size, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        ret = read(fd, data, size);
        if (ret < size) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        return DATA_CONTROL_ERROR_NONE;
@@ -596,40 +628,50 @@ EXPORT_API int data_control_sql_get_double_data(result_set_cursor cursor,
        fd = __cursor->resultset_fd;
        ret = lseek(fd, __cursor->resultset_current_offset, SEEK_SET);
        if (ret < 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to seek in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        /* move to column index */
        for (i = 0; i < column_index; i++) {
                ret = read(fd, &type, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
 
                ret = read(fd, &size, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
+/* LCOV_EXCL_STOP */
                        return DATA_CONTROL_ERROR_IO_ERROR;
                }
 
                ret = lseek(fd, size, SEEK_CUR);
                if (ret < 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to seek in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
        }
 
        ret = read(fd, &type, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        if (type != (int)DATA_CONTROL_SQL_COLUMN_TYPE_DOUBLE) {
@@ -639,16 +681,20 @@ EXPORT_API int data_control_sql_get_double_data(result_set_cursor cursor,
 
        ret = read(fd, &size, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        ret = read(fd, data, size);
        if (ret < size) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        return DATA_CONTROL_ERROR_NONE;
@@ -675,40 +721,50 @@ EXPORT_API int data_control_sql_get_text_data(result_set_cursor cursor,
        fd = __cursor->resultset_fd;
        ret = lseek(fd, __cursor->resultset_current_offset, SEEK_SET);
        if (ret < 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to seek in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        /* move to column index */
        for (i = 0; i < column_index; i++) {
                ret = read(fd, &type, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
 
                ret = read(fd, &size, sizeof(int));
                if (ret == 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
 
                ret = lseek(fd, size, SEEK_CUR);
                if (ret < 0) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to seek in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
        }
 
        ret = read(fd, &type, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        if (type != (int)DATA_CONTROL_SQL_COLUMN_TYPE_TEXT) {
@@ -719,25 +775,31 @@ EXPORT_API int data_control_sql_get_text_data(result_set_cursor cursor,
 
        ret = read(fd, &size, sizeof(int));
        if (ret == 0) {
+/* LCOV_EXCL_START */
                _LOGE("unable to read in the resultset file: %s",
                                strerror_r(errno, err_buf, sizeof(err_buf)));
                return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
        }
 
        if (size > 0 && size < MAX_REQUEST_ARGUMENT_SIZE) {
                data = (char *)malloc((size + 1) * (sizeof(char)));
                if (!data) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to create buffer to read");
                        return DATA_CONTROL_ERROR_OUT_OF_MEMORY;
+/* LCOV_EXCL_STOP */
                }
 
                memset(data, 0, size + 1);
                ret = read(fd, data, size);
                if (ret < size) {
+/* LCOV_EXCL_START */
                        _LOGE("unable to read in the resultset file: %s",
                                        strerror_r(errno, err_buf, sizeof(err_buf)));
                        free(data);
                        return DATA_CONTROL_ERROR_IO_ERROR;
+/* LCOV_EXCL_STOP */
                }
 
                memcpy(buffer, data, size + 1);

diff --git a/tests/unit_tests/src/test_data_control_map.cc b/tests/unit_tests/src/test_data_control_map.cc
index fb17b06d45adf5176be12d7fc3795408135dc7d5..0777db3d3dbd1abddd8d7df3630b33a6abd8e274 100644 (file)
--- a/tests/unit_tests/src/test_data_control_map.cc
+++ b/tests/unit_tests/src/test_data_control_map.cc
@@ -82,6 +82,46 @@ extern GIOFunc __io_func;
 extern gpointer __io_data;
 extern char* __request_type;
 
+TEST_F(DataControlMapTest, map_get_n) {
+  EXPECT_CALL(GetMock<CynaraMock>(),
+      cynara_initialize(_, _)).
+      Times(3).
+      WillOnce(Return(1)).
+      WillOnce(Return(0)).
+      WillOnce(Return(0));
+  EXPECT_CALL(GetMock<CynaraMock>(),
+      cynara_check(_, _, _, _, _)).
+      Times(3).
+      WillOnce(Return(1)).
+      WillOnce(Return(CYNARA_API_ACCESS_ALLOWED)).
+      WillOnce(Return(1));
+
+  int ret;
+  int req;
+  data_control_h provider;
+
+  ret = data_control_map_create(&provider);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+  ret = data_control_map_set_provider_id(provider, "test_providerid");
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+  ret = data_control_map_set_data_id(provider, "test_dataid");
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+  ret = data_control_map_get(provider, "key", &req);
+  EXPECT_NE(ret, DATA_CONTROL_ERROR_NONE);
+
+  ret = data_control_map_get(provider, "key", &req);
+  EXPECT_NE(ret, DATA_CONTROL_ERROR_NONE);
+
+  ret = data_control_map_get(provider, "key", &req);
+  EXPECT_NE(ret, DATA_CONTROL_ERROR_NONE);
+
+  ret = data_control_map_destroy(provider);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+}
+
 TEST_F(DataControlMapTest, map_test) {
   int ret;
   int req_id;
@@ -257,6 +297,48 @@ TEST_F(DataControlMapTest, map_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlMapTest, data_control_map_get_n) {
+  int ret;
+
+  ret = data_control_map_get(NULL, "key",NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlMapTest, data_control_map_get_with_page_n) {
+  int ret;
+
+  ret = data_control_map_get_with_page(NULL, NULL, NULL, 0, 0);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlMapTest, data_control_map_set_n) {
+  int ret;
+
+  ret = data_control_map_set(NULL, NULL, NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlMapTest, data_control_map_add_n) {
+  int ret;
+
+  ret = data_control_map_add(NULL, NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlMapTest, data_control_map_remove_n) {
+  int ret;
+
+  ret = data_control_map_remove(NULL, NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlMapTest, data_control_map_add_bulk_data_n) {
+  int ret;
+
+  ret = data_control_map_add_bulk_data(NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlMapTest, map_bind_unbind_test) {
   int ret;
   char* access;

diff --git a/tests/unit_tests/src/test_data_control_provider.cc b/tests/unit_tests/src/test_data_control_provider.cc
index 20d576a91879fce41d633384076b2db85f07f43c..ea6b918c640659c0f8e8fffed7f81bfdf5f5ed1a 100644 (file)
--- a/tests/unit_tests/src/test_data_control_provider.cc
+++ b/tests/unit_tests/src/test_data_control_provider.cc
@@ -169,6 +169,34 @@ TEST_F(DataControlProviderTest, provider_create_statement_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_create_statement_n) {
+  char *sql = nullptr;
+
+  sql = data_control_provider_create_insert_statement(NULL, NULL);
+  EXPECT_EQ(sql, nullptr);
+}
+
+TEST_F(DataControlProviderTest, provider_update_statement_n) {
+  char *sql = nullptr;
+
+  sql = data_control_provider_create_update_statement(NULL, NULL, NULL);
+  EXPECT_EQ(sql, nullptr);
+}
+
+TEST_F(DataControlProviderTest, provider_select_statement_n) {
+  char *sql = nullptr;
+
+  sql = data_control_provider_create_select_statement(NULL, NULL, 0, NULL, NULL);
+  EXPECT_EQ(sql, nullptr);
+}
+
+TEST_F(DataControlProviderTest, provider_delete_statement_n) {
+  char *sql = nullptr;
+
+  sql = data_control_provider_create_delete_statement(NULL, NULL);
+  EXPECT_EQ(sql, nullptr);
+}
+
 TEST_F(DataControlProviderTest, provider_match_test) {
   int ret;
   bool is_match = false;
@@ -195,11 +223,25 @@ TEST_F(DataControlProviderTest, provider_match_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_match_n) {
+  bool is_match = false;
+
+  is_match = data_control_provider_match_provider_id(NULL, "test_providerid");
+  EXPECT_FALSE(is_match);
+}
+
 bool _data_control_provider_data_change_consumer_filter_cb(data_control_h provider,
               char *consumer_appid, void *user_data) {
   return true;
 }
 
+TEST_F(DataControlProviderTest, provider_match_n2) {
+  bool is_match = false;
+
+  is_match = data_control_provider_match_data_id(NULL, "test_providerid");
+  EXPECT_FALSE(is_match);
+}
+
 TEST_F(DataControlProviderTest, provider_add_remove_cb_test) {
   int ret;
   int callback_id;
@@ -230,9 +272,15 @@ TEST_F(DataControlProviderTest, provider_send_result_test_n) {
   ret = data_control_provider_send_bulk_insert_result(99, result_data_h);
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
 
+  ret = data_control_provider_send_bulk_insert_result(99, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+
   ret = data_control_provider_send_map_bulk_add_result(99, result_data_h);
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
 
+  ret = data_control_provider_send_map_bulk_add_result(99, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+
   ret = data_control_bulk_result_data_destroy(result_data_h);
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
@@ -440,6 +488,20 @@ TEST_F(DataControlProviderTest, provider_send_select_result_test) {
   bundle_free(b);
 }
 
+TEST_F(DataControlProviderTest, provider_send_select_result_n) {
+  int ret;
+
+  ret = data_control_provider_send_select_result(99, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlProviderTest, data_control_provider_get_client_appid_n) {
+  int ret;
+
+  ret = data_control_provider_get_client_appid(1, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlProviderTest, provider_send_insert_result_test) {
   int ret;
 
@@ -451,6 +513,13 @@ TEST_F(DataControlProviderTest, provider_send_insert_result_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_send_insert_result_n) {
+  int ret;
+
+  ret = data_control_provider_send_insert_result(99, 0);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlProviderTest, provider_send_update_result_test) {
   int ret;
 
@@ -463,6 +532,14 @@ TEST_F(DataControlProviderTest, provider_send_update_result_test) {
 
 }
 
+TEST_F(DataControlProviderTest, provider_send_update_result_n) {
+  int ret;
+
+  ret = data_control_provider_send_update_result(99);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+
+}
+
 TEST_F(DataControlProviderTest, provider_send_delete_result_test) {
   int ret;
 
@@ -474,6 +551,12 @@ TEST_F(DataControlProviderTest, provider_send_delete_result_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_send_delete_result_n) {
+  int ret;
+
+  ret = data_control_provider_send_delete_result(99);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
 
 TEST_F(DataControlProviderTest, provider_send_error_result_test) {
   int ret;
@@ -486,6 +569,13 @@ TEST_F(DataControlProviderTest, provider_send_error_result_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_send_error_result_n) {
+  int ret;
+
+  ret = data_control_provider_send_error(99, "test_errors");
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlProviderTest, provider_send_map_result_test) {
   int ret;
   pkgmgrinfo_cert_compare_result_type_e res = PMINFO_CERT_COMPARE_MATCH;
@@ -535,6 +625,13 @@ TEST_F(DataControlProviderTest, provider_send_map_result_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_send_map_result_n) {
+  int ret;
+
+  ret = data_control_provider_send_map_result(99);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlProviderTest, provider_send_map_get_value_result_test) {
   int ret;
   char* value_list[2];
@@ -550,6 +647,13 @@ TEST_F(DataControlProviderTest, provider_send_map_get_value_result_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_send_map_get_value_result_n) {
+  int ret;
+
+  ret = data_control_provider_send_map_get_value_result(88, NULL, 2);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlProviderTest, provider_send_select_result_without_data_test) {
   int ret;
   int fd;
@@ -562,6 +666,13 @@ TEST_F(DataControlProviderTest, provider_send_select_result_without_data_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_send_select_result_without_data_n) {
+  int ret;
+
+  ret = datacontrol_provider_send_select_result_without_data(99, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlProviderTest, provider_get_select_page_info_test) {
   int ret;
   int page_num;
@@ -575,6 +686,13 @@ TEST_F(DataControlProviderTest, provider_get_select_page_info_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlProviderTest, provider_get_select_page_info_n) {
+  int ret;
+
+  ret = datacontrol_provider_get_select_page_info(99, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlProviderTest, data_control_provider_send_bulk_insert_result) {
   int ret;
   Bundle b;

diff --git a/tests/unit_tests/src/test_data_control_sql.cc b/tests/unit_tests/src/test_data_control_sql.cc
index 701cc1946fe33ee001145e45443267818f27bc32..e1db4ab0738cfcde7312b1cea15e5fcdc020537c 100644 (file)
--- a/tests/unit_tests/src/test_data_control_sql.cc
+++ b/tests/unit_tests/src/test_data_control_sql.cc
@@ -267,6 +267,36 @@ TEST_F(DataControlSqlTest, sql_test) {
   EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
 }
 
+TEST_F(DataControlSqlTest, data_control_sql_insert_bulk_data_n) {
+  int ret;
+  ret = data_control_sql_insert_bulk_data(NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlSqlTest, data_control_sql_insert_n) {
+  int ret;
+  ret = data_control_sql_insert(NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlSqlTest, data_control_sql_delete_n) {
+  int ret;
+  ret = data_control_sql_delete(NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlSqlTest, data_control_sql_select_with_page_n) {
+  int ret;
+  ret = data_control_sql_select_with_page(NULL, NULL, 0, NULL, NULL, 0, 0, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(DataControlSqlTest, data_control_sql_update_n) {
+  int ret;
+  ret = data_control_sql_update(NULL, NULL, NULL, NULL);
+  EXPECT_EQ(ret, DATA_CONTROL_ERROR_INVALID_PARAMETER);
+}
+
 TEST_F(DataControlSqlTest, sql_bind_unbind_cb_test) {
   int ret;
   char* app_id;