fi
#################################################
-# widget_service_unittests
+# widget-service-unittests
#################################################
-%package -n widget_service_unittests
+%package -n widget-service-unittests
Summary: GTest for widget_service
Group: Development/Libraries
-%description -n widget_service_unittests
+%description -n widget-service-unittests
GTest for widget_service
-%files -n widget_service_unittests
+%files -n widget-service-unittests
%{_bindir}/widget_service_unittests
%{_bindir}/tizen-unittests/%{name}/run-unittest.sh
return "";
}
-
+/* LCOV_EXCL_START */
bool BusyHandler(int count) {
constexpr int BUSY_WAITING_USEC = 50000;
constexpr int BUSY_WAITING_MAX = 20;
return false;
}
-
+/* LCOV_EXCL_STOP */
int IsGlobal(uid_t uid) {
constexpr int ROOT_USER = 0;
return -1;
}
-/* LCOV_EXCL_START */
static int __check_valid_sender_v2(const char *sender_pkgid)
{
char pkgid[256] = {0, };
return -1;
}
-/* LCOV_EXCL_STOP */
static int __status_handler(const char *endpoint, aul_app_com_result_e e, bundle *envelope, void *user_data)
{
fd = open("/proc/self/attr/current", O_RDONLY);
if (fd < 0) {
+/* LCOV_EXCL_START */
LOGE("open [%d] failed!", errno);
ret = -1;
+/* LCOV_EXCL_STOP */
goto out;
}
ret = read(fd, subject_label, SMACK_LABEL_LEN);
if (ret < 0) {
+/* LCOV_EXCL_START */
LOGE("read [%d] failed!", errno);
close(fd);
ret = -1;
goto out;
+/* LCOV_EXCL_STOP */
}
close(fd);
printf("chown fail %s", path);
return WIDGET_ERROR_FAULT;
}
-
+/* LCOV_EXCL_START */
mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
ret = chmod(path, mode);
if (ret == -1) {
printf("chmod failed : %s", path);
return WIDGET_ERROR_FAULT;;
}
-
+/* LCOV_EXCL_STOP */
return WIDGET_ERROR_NONE;
}
SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
NULL);
if (ret != SQLITE_OK) {
+/* LCOV_EXCL_START */
_E("Failed to open db[%d]", ret);
sqlite3_close_v2(db);
unlink(path);
return WIDGET_ERROR_FAULT;
+/* LCOV_EXCL_STOP */
}
ret = sqlite3_exec(db, CREATE_WIDGET_TABLE, NULL, NULL, &errmsg);
sqlite3_close_v2(db);
if (ret != SQLITE_OK) {
+/* LCOV_EXCL_START */
_E("Failed to exec query[%d][%s]", ret, errmsg);
sqlite3_free(errmsg);
return WIDGET_ERROR_FAULT;
+/* LCOV_EXCL_STOP */
}
__change_smack(path);
ret = sqlite3_exec(db, "PRAGMA integrity_check",
_check_integrity_cb, NULL, &errmsg);
if (ret != SQLITE_OK || _is_corrupted) {
+/* LCOV_EXCL_START */
_E("Failed to exec query[%d][%s]", ret, errmsg);
sqlite3_free(errmsg);
return WIDGET_ERROR_FAULT;
+/* LCOV_EXCL_STOP */
}
return WIDGET_ERROR_NONE;
return path;
}
-
+/* LCOV_EXCL_START */
static void _resolution_update_size_list(int width_type, int height_type, int width, int height)
{
int idx = 0;
_I("size type(%d): %dx%d (%dx%d)\n", idx, width_type, height_type, width, height);
}
-
+/* LCOV_EXCL_STOP */
static int _resolution_update_from_file(void)
{
int width_type = 0;
file_path = _resolution_file_path();
if (file_path == NULL)
return WIDGET_ERROR_OUT_OF_MEMORY;
-
+/* LCOV_EXCL_START */
dic = iniparser_load(file_path);
if (dic == NULL) {
_E("fail to load [%s] ", file_path);
return WIDGET_ERROR_NONE;
}
-
+/* LCOV_EXCL_STOP */
static int _get_supported_size_type(int width, int height, int *type)
{
int i;
sqlite3_reset(stmt);
width = malloc(sizeof(int) * count);
if (!width) {
+/* LCOV_EXCL_START */
_E("Failed to allocate width");
ret = WIDGET_ERROR_FAULT; /* It shoud be WIDGET_ERROR_OUT_OF_MEMORY */
goto err;
+/* LCOV_EXCL_STOP */
}
height = malloc(sizeof(int) * count);
if (!height) {
+/* LCOV_EXCL_START */
_E("Failed to allocate height");
ret = WIDGET_ERROR_FAULT; /* It should be WIDGET_ERROR_OUT_OF_MEMORY */
goto err;
+/* LCOV_EXCL_STOP */
}
for (i = 0; i < count; i++) {
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
_E("sqlite3_step() is failed. err(%s)",
sqlite3_errmsg(db));
ret = WIDGET_ERROR_FAULT;
goto err;
+/* LCOV_EXCL_STOP */
}
_get_column_int(stmt, 0, &width[i]);
_get_column_int(stmt, 1, &height[i]);
sqlite3_reset(stmt);
width = malloc(sizeof(int) * count);
if (!width) {
+/* LCOV_EXCL_START */
_E("Failed to allocate width");
ret = WIDGET_ERROR_FAULT; /* It should be WIDGET_ERROR_OUT_OF_MEMORY */
goto err;
+/* LCOV_EXCL_STOP */
}
height = malloc(sizeof(int) * count);
if (!height) {
+/* LCOV_EXCL_START */
_E("Failed to allocate height");
ret = WIDGET_ERROR_FAULT; /* It should be WIDGET_ERROR_OUT_OF_MEMORY */
goto err;
+/* LCOV_EXCL_STOP */
}
type = malloc(sizeof(int) * count);
if (!type) {
+/* LCOV_EXCL_START */
_E("Failed to allocate type");
ret = WIDGET_ERROR_FAULT; /* It should be WIDGET_ERROR_OUT_OF_MEMORY */
goto err;
+/* LCOV_EXCL_STOP */
}
for (i = 0; i < count; i++) {
widget_instance_h instance;
struct widget_instance_info_s instance_info;
int ret;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (!pkgname || !id || period < 0.0f) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
int ret;
bundle_raw *raw = NULL;
int len;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (!widget_id) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
GList *list = NULL;
GList *tmp;
struct widget_list_item *item;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (cb == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
GList *list = NULL;
GList *tmp;
struct widget_list_item *item;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (pkgid == NULL || cb == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+ /* LCOV_EXCL_START */
/* TODO: which error should be set? */
if (ret == SQLITE_DONE) {
set_last_result(WIDGET_ERROR_NOT_EXIST);
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
return NULL;
+ /* LCOV_EXCL_STOP */
}
_get_column_str(stmt, 0, &pkgid);
EAPI char *widget_service_get_main_app_id(const char *widget_id)
{
char *appid;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return NULL;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("invalid parameter");
set_last_result(WIDGET_ERROR_INVALID_PARAMETER);
int ret;
int *width = NULL;
int *height = NULL;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL || cnt == NULL || types == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
EAPI char *widget_service_get_app_id_of_setup_app(const char *widget_id)
{
char *appid;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return NULL;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("invalid parameter");
set_last_result(WIDGET_ERROR_INVALID_PARAMETER);
ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
if (ret != SQLITE_OK) {
+/* LCOV_EXCL_START */
_E("prepare error: %s", sqlite3_errmsg(db));
sqlite3_close_v2(db);
set_last_result(WIDGET_ERROR_FAULT);
return 0;
+/* LCOV_EXCL_STOP */
}
sqlite3_bind_text(stmt, 1, widget_id, -1, SQLITE_STATIC);
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
/* TODO: which error should be set? */
if (ret == SQLITE_DONE) {
set_last_result(WIDGET_ERROR_NOT_EXIST);
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
return 0;
+/* LCOV_EXCL_STOP */
}
_get_column_int(stmt, 0, &nodisplay);
ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
if (ret != SQLITE_OK) {
+/* LCOV_EXCL_START */
_E("prepare error: %s", sqlite3_errmsg(db));
sqlite3_close_v2(db);
return WIDGET_ERROR_FAULT;
+/* LCOV_EXCL_STOP */
}
sqlite3_bind_text(stmt, 1, widget_id, -1, SQLITE_STATIC);
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
if (ret == SQLITE_DONE) {
ret = WIDGET_ERROR_NOT_EXIST;
} else {
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
return ret;
+/* LCOV_EXCL_STOP */
}
_get_column_double(stmt, 0, period);
EAPI int widget_service_get_nodisplay(const char *widget_id)
{
int nodisplay;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return 0;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("invalid parameter");
set_last_result(WIDGET_ERROR_INVALID_PARAMETER);
/* deprecated, always return need_of_frame as false */
EAPI int widget_service_get_need_of_frame(const char *pkgid, widget_size_type_e size_type, bool *need_of_frame)
{
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (!pkgid) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
/* deprecated, always return need_of_touch_event as false */
EAPI int widget_service_get_need_of_touch_effect(const char *pkgid, widget_size_type_e size_type, bool *need_of_touch_event)
{
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (!pkgid) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
/* deprecated, always return need_of_mouse_event as false */
EAPI int widget_service_get_need_of_mouse_event(const char *pkgid, widget_size_type_e size_type, bool *need_of_mouse_event)
{
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (!pkgid) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
/* TODO: which error should be set? */
if (ret == SQLITE_DONE) {
set_last_result(WIDGET_ERROR_NOT_EXIST);
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
return NULL;
+/* LCOV_EXCL_STOP */
}
_get_column_str(stmt, 0, &path);
int buf_len;
int i;
int printed;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return NULL;
}
-
+/* LCOV_EXCL_STOP */
/* TODO: validate size_type */
if (widget_id == NULL) {
_E("invalid parameter");
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
if (ret != SQLITE_DONE)
_E("step error: %s", sqlite3_errmsg(db));
sqlite3_finalize(stmt);
set_last_result(ret == SQLITE_DONE ? WIDGET_ERROR_NOT_EXIST :
WIDGET_ERROR_FAULT);
return NULL;
+/* LCOV_EXCL_STOP */
}
_get_column_str(stmt, 0, &widget_id);
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
if (ret != SQLITE_DONE)
_E("step error: %s", sqlite3_errmsg(db));
sqlite3_finalize(stmt);
set_last_result(ret == SQLITE_DONE ? WIDGET_ERROR_NOT_EXIST :
WIDGET_ERROR_FAULT);
return NULL;
+/* LCOV_EXCL_STOP */
}
_get_column_str(stmt, 0, &icon);
{
char *icon;
char *widget_id;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return NULL;
}
-
+/* LCOV_EXCL_STOP */
if (pkgid == NULL) {
_E("invalid parameter");
set_last_result(WIDGET_ERROR_INVALID_PARAMETER);
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
if (ret != SQLITE_DONE)
_E("step error: %s", sqlite3_errmsg(db));
sqlite3_finalize(stmt);
set_last_result(ret == SQLITE_DONE ? WIDGET_ERROR_NOT_EXIST :
WIDGET_ERROR_FAULT);
return NULL;
+/* LCOV_EXCL_STOP */
}
_get_column_str(stmt, 0, &label);
char *name;
char *language;
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return NULL;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("invalid parameter");
set_last_result(WIDGET_ERROR_INVALID_PARAMETER);
int **w, int **h)
{
int ret;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL || cnt == NULL || w == NULL || h == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
_E("step error: %s", sqlite3_errmsg(db));
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
set_last_result(ret == SQLITE_DONE ? WIDGET_ERROR_NOT_EXIST :
WIDGET_ERROR_FAULT);
return NULL;
+/* LCOV_EXCL_STOP */
}
_get_column_str(stmt, 0, &classid);
if (widget_list == NULL)
goto end;
-
+/* LCOV_EXCL_START */
iter = g_list_first(widget_list);
while (iter) {
item = (struct widget_list_item *)iter->data;
free(item);
}
}
-
+/* LCOV_EXCL_STOP */
end:
if (pkginfo)
pkgmgrinfo_pkginfo_destroy_pkginfo(pkginfo);
{
char *classid;
char *widget_id;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return NULL;
}
-
+/* LCOV_EXCL_STOP */
if (appid == NULL) {
_E("invalid parameter");
set_last_result(WIDGET_ERROR_INVALID_PARAMETER);
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
/* TODO: which error should be set? */
if (ret == SQLITE_DONE) {
set_last_result(WIDGET_ERROR_NOT_EXIST);
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
return NULL;
+/* LCOV_EXCL_STOP */
}
_get_column_str(stmt, 0, &pkgid);
EAPI char *widget_service_get_package_id(const char *widget_id)
{
char *pkgid;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
set_last_result(WIDGET_ERROR_NOT_SUPPORTED);
return NULL;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("invalid parameter");
set_last_result(WIDGET_ERROR_INVALID_PARAMETER);
EAPI int widget_service_get_size(widget_size_type_e type, int *width,
int *height)
{
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (width == NULL || height == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
EAPI int widget_service_get_size_type(int width, int height,
widget_size_type_e *size_type)
{
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (width <= 0 || height <= 0 || size_type == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
{
char *raw = NULL;
int ret;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL || widget_instance_id == NULL || b == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
cb_data.cb = cb;
cb_data.data = data;
cb_data.cnt = 0;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL || cb == NULL) {
_E("inavlid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
int ret = WIDGET_ERROR_NONE;
struct lifecycle_s *cb_info;
GList *head = lifecycle_cbs;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (cb == NULL) {
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
struct lifecycle_s *cb_info;
struct lifecycle_s *found = NULL;
GList *head = lifecycle_cbs;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
while (head) {
cb_info = (struct lifecycle_s *)head->data;
if (cb_info && widget_id && cb_info->widget_id) {
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
if (ret == SQLITE_DONE) {
ret = WIDGET_ERROR_NOT_EXIST;
} else {
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
return ret;
+/* LCOV_EXCL_STOP */
}
_get_column_int(stmt, 0, &max_instance);
EAPI int widget_service_get_widget_max_count(const char *widget_id)
{
int ret;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("Not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("Invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
EAPI int widget_service_get_instance_count(const char *widget_id, const char *cluster, const char *category)
{
int ret;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("Not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("Invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
bool disabled)
{
int ret;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("Not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL) {
_E("Invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW) {
+/* LCOV_EXCL_START */
if (ret == SQLITE_DONE) {
ret = WIDGET_ERROR_NOT_EXIST;
} else {
sqlite3_finalize(stmt);
sqlite3_close_v2(db);
return ret;
+/* LCOV_EXCL_STOP */
}
_get_column_int(stmt, 0, &disable);
bool *is_disabled)
{
int ret;
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("Not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (widget_id == NULL || is_disabled == NULL) {
_E("Invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
_E("invalid parameter");
return WIDGET_ERROR_INVALID_PARAMETER;
}
-
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("Not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (check_privilege("http://tizen.org/privilege/widget.viewer") < 0)
return WIDGET_ERROR_PERMISSION_DENIED;
EAPI int widget_service_unset_disable_event_cb(void)
{
+/* LCOV_EXCL_START */
if (!_is_widget_feature_enabled()) {
_E("not supported");
return WIDGET_ERROR_NOT_SUPPORTED;
}
-
+/* LCOV_EXCL_STOP */
if (check_privilege("http://tizen.org/privilege/widget.viewer") < 0)
return WIDGET_ERROR_PERMISSION_DENIED;
aul_app_com_permission_h arg2, app_com_cb arg3, void* arg4,
aul_app_com_connection_h* arg5) {
return MOCK_HOOK_P5(AulMock, aul_app_com_create, arg1, arg2, arg3, arg4, arg5);
+}
+
+extern "C" int aul_app_get_pkgid_bypid(int pid, char *pkgid, int len) {
+ return MOCK_HOOK_P3(AulMock, aul_app_get_pkgid_bypid, pid, pkgid, len);
}
\ No newline at end of file
const char *, char **));
MOCK_METHOD5(aul_app_com_create, int (const char *, aul_app_com_permission_h,
app_com_cb, void *, aul_app_com_connection_h *));
+ MOCK_METHOD3(aul_app_get_pkgid_bypid, int (int , char *, int));
};
return MOCK_HOOK_P2(PkgMgrInfoMock, pkgmgrinfo_pkginfo_get_root_path, handle,
root_path);
}
+
+extern "C" int pkgmgrinfo_pkginfo_get_pkginfo(const char* arg1,
+ pkgmgrinfo_pkginfo_h* arg2) {
+ return MOCK_HOOK_P2(PkgMgrInfoMock, pkgmgrinfo_pkginfo_get_pkginfo,
+ arg1, arg2);
+}
+
+extern "C" int pkgmgrinfo_appinfo_get_appinfo(const char* arg1,
+ pkgmgrinfo_appinfo_h* arg2) {
+ return MOCK_HOOK_P2(PkgMgrInfoMock, pkgmgrinfo_appinfo_get_appinfo,
+ arg1, arg2);
+}
+
+extern "C" int pkgmgrinfo_appinfo_get_pkgid(pkgmgrinfo_appinfo_h arg1,
+ char** arg2) {
+ return MOCK_HOOK_P2(PkgMgrInfoMock, pkgmgrinfo_appinfo_get_pkgid, arg1, arg2);
+}
\ No newline at end of file
int (pkgmgrinfo_pkginfo_h));
MOCK_METHOD2(pkgmgrinfo_pkginfo_get_root_path,
int (pkgmgrinfo_pkginfo_h, char**));
+ MOCK_METHOD2(pkgmgrinfo_pkginfo_get_pkginfo,
+ int (const char*, pkgmgrinfo_pkginfo_h*));
+ MOCK_METHOD2(pkgmgrinfo_appinfo_get_appinfo,
+ int (const char*, pkgmgrinfo_appinfo_h*));
+ MOCK_METHOD2(pkgmgrinfo_appinfo_get_pkgid,
+ int (pkgmgrinfo_appinfo_h, char**));
};
#endif // UNIT_TESTS_MOCK_PKGMGR_INFO_MOCK_H_
\ No newline at end of file
extern "C" int system_info_get_platform_bool(const char* arg1, bool* arg2) {
return MOCK_HOOK_P2(SystemInfoMock, system_info_get_platform_bool, arg1, arg2);
+}
+
+extern "C" int system_info_get_platform_int(const char* arg1, int* arg2) {
+ return MOCK_HOOK_P2(SystemInfoMock, system_info_get_platform_int, arg1, arg2);
}
\ No newline at end of file
MOCK_METHOD0(getuid, uid_t (void));
MOCK_METHOD2(system_info_get_platform_bool, int (const char*, bool*));
+ MOCK_METHOD2(system_info_get_platform_int, int (const char*, int*));
};
#endif // UNIT_TESTS_MOCK_SYSTEM_INFO_MOCK_H_
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "vconf_mock.h"
+#include "mock_hook.h"
+#include "test_fixture.h"
+
+extern "C" char* vconf_get_str(const char* in_key) {
+ return MOCK_HOOK_P1(VconfMock, vconf_get_str, in_key);
+}
--- /dev/null
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UNIT_TESTS_MOCK_VCONF_MOCK_H_
+#define UNIT_TESTS_MOCK_VCONF_MOCK_H_
+
+#include <vconf.h>
+#include <gmock/gmock.h>
+
+#include "module_mock.h"
+
+class VconfMock : public virtual ModuleMock {
+ public:
+ virtual ~VconfMock() {}
+
+ MOCK_METHOD1(vconf_get_str, char* (const char*));
+};
+
+#endif // MOCK_VCONF_MOCUNIT_TESTS_MOCK_VCONF_MOCK_H__H_
\ No newline at end of file
using ::testing::_;
using ::testing::DoAll;
using ::testing::Invoke;
-using ::testing::SetArgPointee;
using ::testing::Return;
namespace {
#include <stdio.h>
#include <sqlite3.h>
#include <dlfcn.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "include/widget_instance.h"
#include "include/widget_service.h"
#include "include/widget_errno.h"
#include "include/widget_service_internal.h"
#include "glib_mock.h"
#include "tzplatform_config_mock.h"
#include "pkgmgr-info_mock.h"
+#include "vconf_mock.h"
#include "test_fixture.h"
#include "widget_plugin_parser.hh"
#include "widget_plugin_parser_error.h"
using ::testing::_;
using ::testing::DoAll;
using ::testing::Invoke;
-using ::testing::SetArgPointee;
+using ::testing::InvokeArgument;
using ::testing::Return;
namespace {
return PMINFO_R_OK;
}
+int __fake_system_info_get_platform_int1(const char *key, int *val) {
+ *val = 320;
+ return SYSTEM_INFO_ERROR_NONE;
+}
+
+int __fake_system_info_get_platform_int2(const char *key, int *val) {
+ *val = 480;
+ return SYSTEM_INFO_ERROR_NONE;
+}
+
class Mocks : virtual public ::testing::NiceMock<AulMock>,
virtual public ::testing::NiceMock<CynaraMock>,
virtual public ::testing::NiceMock<GlibMock>,
virtual public ::testing::NiceMock<PkgMgrInfoMock>,
virtual public ::testing::NiceMock<SystemInfoMock>,
- virtual public ::testing::NiceMock<TzplatformConfigMock> {};
+ virtual public ::testing::NiceMock<TzplatformConfigMock>,
+ virtual public ::testing::NiceMock<VconfMock> {};
constexpr char XML1[] = R"__widget(<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<manifest xmlns="http://tizen.org/ns/packages" api-version="5.5" package="org.tizen.gallery_common" version="1.0.0">
</widget-application>
</manifest>
)__widget";
-
} // namespace
class WidgetServiceTest : public TestFixture {
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
}
+TEST_F(WidgetServiceTest, GetDisabled_N) {
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
+ .WillOnce(Return(1));
+
+ int ret = WIDGET_ERROR_NONE;
+ bool is_disabled;
+
+ ret = widget_service_get_widget_disabled(NULL,
+ &is_disabled);
+ ASSERT_EQ(ret, WIDGET_ERROR_INVALID_PARAMETER);
+
+ ret = widget_service_get_widget_disabled("org.tizen.gallery.widget",
+ &is_disabled);
+ ASSERT_EQ(ret, WIDGET_ERROR_PERMISSION_DENIED);
+}
+
+
void _widget_disable_event_cb(const char *widget_id, bool is_disabled, void *user_data) {
}
.WillRepeatedly(Invoke(__fake_cynara_check));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
.WillRepeatedly(Invoke(__fake_cynara_finish));
+
+ bundle *b = bundle_create();
+ bundle_add_str(b, AUL_K_WIDGET_DISABLE, "1");
+ bundle_add_str(b, AUL_K_WIDGET_ID, "widget_id");
EXPECT_CALL(GetMock<AulMock>(), aul_app_com_create(_, _, _, _, _))
- .WillRepeatedly(Invoke(__fake_aul_app_com_create));
+ .WillOnce(DoAll(InvokeArgument<2>("end", AUL_APP_COM_R_OK, b, nullptr),
+ Return(0)));
EXPECT_CALL(GetMock<AulMock>(), aul_app_com_leave(_))
.WillRepeatedly(Invoke(__fake_aul_app_com_leave));
ret = widget_service_set_disable_event_cb(_widget_disable_event_cb, NULL);
ret = widget_service_unset_disable_event_cb();
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
+ bundle_free(b);
}
TEST_F(WidgetServiceTest, GetSize) {
+ int width, height;
+
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_int(_, _))
+ .Times(2)
+ .WillOnce(Invoke(__fake_system_info_get_platform_int1))
+ .WillOnce(Invoke(__fake_system_info_get_platform_int2));
int ret;
- int width, height;
ret = widget_service_get_size(WIDGET_SIZE_TYPE_4x4, &width, &height);
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
TEST_F(WidgetServiceTest, GetSizeType) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_int(_, _))
+ .WillRepeatedly(Return(0));
int ret;
widget_size_type_e type;
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
}
+TEST_F(WidgetServiceTest, TriggerUpdate_N1) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+
+ int ret;
+
+ ret = widget_service_trigger_update(NULL,
+ "org.tizen.gallery.widget", NULL, 1);
+ ASSERT_EQ(ret, WIDGET_ERROR_INVALID_PARAMETER);
+}
+
TEST_F(WidgetServiceTest, ChangePeriod) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
}
+TEST_F(WidgetServiceTest, ChangePeriod_N2) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+
+ int ret;
+
+ ret = widget_service_change_period(NULL,
+ "org.tizen.gallery.widget", 1.0);
+ ASSERT_EQ(ret, WIDGET_ERROR_INVALID_PARAMETER);
+}
+
int _widget_list_cb(const char *pkgid, const char *widget_id, int is_prime, void *user_data) {
return 0;
}
ASSERT_EQ(ret, 1);
}
+TEST_F(WidgetServiceTest, GetWidgetList_N1) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+
+ int ret;
+
+ ret = widget_service_get_widget_list(NULL, NULL);
+ ASSERT_EQ(ret, WIDGET_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(WidgetServiceTest, GetWidgetList_N3) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
+ .WillRepeatedly(Return(1));
+
+ int ret;
+
+ ret = widget_service_get_widget_list(_widget_list_cb, NULL);
+ ASSERT_EQ(ret, WIDGET_ERROR_PERMISSION_DENIED);
+}
+
TEST_F(WidgetServiceTest, GetMainAppId) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
ASSERT_STREQ(p.get(), "org.tizen.mainappid");
}
+TEST_F(WidgetServiceTest, GetMainAppId_N1) {
+ char *app_id = NULL;
+
+ app_id = widget_service_get_main_app_id(NULL);
+ ASSERT_STREQ(app_id, NULL);
+}
+
+TEST_F(WidgetServiceTest, GetMainAppId_N2) {
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
+ .WillRepeatedly(Return(1));
+ char *app_id = NULL;
+
+ app_id = widget_service_get_main_app_id("org.tizen.gallery.widget");
+ ASSERT_STREQ(app_id, NULL);
+}
+
int _widget_list_by_pkgid_cb(const char *widget_id, int is_prime, void *user_data) {
return 0;
}
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
}
+TEST_F(WidgetServiceTest, GetWidgetListByPkgId_N1) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+
+ int ret;
+
+ ret = widget_service_get_widget_list_by_pkgid(NULL,
+ _widget_list_by_pkgid_cb, NULL);
+ ASSERT_EQ(ret, WIDGET_ERROR_INVALID_PARAMETER);
+}
+
TEST_F(WidgetServiceTest, GetWidgetId) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
ASSERT_STREQ(p.get(), "org.tizen.gallery.widget");
}
+TEST_F(WidgetServiceTest, GetWidgetId_N) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
+ .Times(2)
+ .WillOnce(Invoke(__fake_cynara_initialize))
+ .WillOnce(Return(1));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
+ .WillRepeatedly(Invoke(__fake_cynara_check));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
+ .WillRepeatedly(Invoke(__fake_cynara_finish));
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+ EXPECT_CALL(GetMock<PkgMgrInfoMock>(), pkgmgrinfo_pkginfo_get_pkginfo(_, _))
+ .Times(2)
+ .WillOnce(Return(1))
+ .WillOnce(Return(0));
+ EXPECT_CALL(GetMock<PkgMgrInfoMock>(), pkgmgrinfo_appinfo_get_appinfo(_, _))
+ .WillRepeatedly(Return(0));
+ EXPECT_CALL(GetMock<PkgMgrInfoMock>(), pkgmgrinfo_appinfo_get_pkgid(_, _))
+ .WillRepeatedly(Invoke([](pkgmgrinfo_appinfo_h info, char **pkgid) -> int {
+ *pkgid = (char *)"org.tizen.gallery.widget";
+ return 0;
+ }));
+
+
+ char *widget_id = NULL;
+
+ widget_id = widget_service_get_widget_id("org.tizen.gallery.widget_invalid");
+ auto p = std::unique_ptr<char, decltype(std::free)*>(widget_id, std::free);
+ EXPECT_NE(p.get(), "org.tizen.gallery.widget");
+
+ widget_id = widget_service_get_widget_id("org.tizen.gallery.widget_invalid");
+ ASSERT_EQ(widget_id, nullptr);
+
+ widget_id = widget_service_get_widget_id(NULL);
+ ASSERT_EQ(widget_id, nullptr);
+}
+
TEST_F(WidgetServiceTest, GetAppIdOfSetupApp) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
app_id = widget_service_get_app_id_of_setup_app("org.tizen.gallery.widget");
auto p = std::unique_ptr<char, decltype(std::free)*>(app_id, std::free);
-
ASSERT_STREQ(p.get(), "org.tizen.setup_appid");
}
+TEST_F(WidgetServiceTest, GetAppIdOfSetupApp_N) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
+ .Times(2)
+ .WillOnce(Invoke(__fake_cynara_initialize))
+ .WillOnce(Return(1));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
+ .WillRepeatedly(Invoke(__fake_cynara_check));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
+ .WillRepeatedly(Invoke(__fake_cynara_finish));
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+
+ char *app_id = NULL;
+
+ app_id = widget_service_get_app_id_of_setup_app("org.tizen.gallery.widget_inv");
+ ASSERT_EQ(app_id, nullptr);
+
+ app_id = widget_service_get_app_id_of_setup_app(NULL);
+ ASSERT_EQ(app_id, nullptr);
+
+ app_id = widget_service_get_app_id_of_setup_app("org.tizen.gallery.widget");
+ ASSERT_EQ(app_id, nullptr);
+}
+
TEST_F(WidgetServiceTest, GetPackageId) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
- .WillRepeatedly(Invoke(__fake_cynara_initialize));
+ .Times(2)
+ .WillOnce(Invoke(__fake_cynara_initialize))
+ .WillOnce(Return(1));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
.WillRepeatedly(Invoke(__fake_cynara_check));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
package_id = widget_service_get_package_id("org.tizen.gallery.widget");
auto p = std::unique_ptr<char, decltype(std::free)*>(package_id, std::free);
ASSERT_STREQ(p.get(), "org.tizen.gallery_common");
+
+ //For code coverage
+ package_id = widget_service_get_package_id("org.tizen.gallery.widget");
+ ASSERT_EQ(package_id, nullptr);
+
+ package_id = widget_service_get_package_id(NULL);
+ ASSERT_EQ(package_id, nullptr);
}
TEST_F(WidgetServiceTest, GetName) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
- .WillRepeatedly(Invoke(__fake_cynara_initialize));
+ .Times(2)
+ .WillOnce(Invoke(__fake_cynara_initialize))
+ .WillOnce(Return(1));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
.WillRepeatedly(Invoke(__fake_cynara_check));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
name = widget_service_get_name("org.tizen.gallery.widget", "en-us");
auto p = std::unique_ptr<char, decltype(std::free)*>(name, std::free);
ASSERT_STREQ(p.get(), "Gallery");
+
+ // For code coverage
+ name = widget_service_get_name(NULL, "en-us");
+ ASSERT_EQ(name, nullptr);
+
+ name = widget_service_get_name("org.tizen.gallery.widget", "en-us");
+ ASSERT_EQ(name, nullptr);
}
-TEST_F(WidgetServiceTest, GetPreviewImagePath) {
+TEST_F(WidgetServiceTest, GetName2) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
.WillRepeatedly(Invoke(__fake_cynara_finish));
EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
.WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+ char *lang = strdup("en-us");
+ EXPECT_CALL(GetMock<VconfMock>(), vconf_get_str(_))
+ .WillRepeatedly(Return(lang));
+
+ char *name = NULL;
+
+ name = widget_service_get_name("org.tizen.gallery.widget", NULL);
+ auto p = std::unique_ptr<char, decltype(std::free)*>(name, std::free);
+ EXPECT_STREQ(p.get(), "Gallery");
+}
+
+TEST_F(WidgetServiceTest, GetPreviewImagePath) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
+ .Times(2)
+ .WillOnce(Invoke(__fake_cynara_initialize))
+ .WillOnce(Return(1));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
+ .WillRepeatedly(Invoke(__fake_cynara_check));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
+ .WillRepeatedly(Invoke(__fake_cynara_finish));
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+ char *lang = strdup("en-us");
+ EXPECT_CALL(GetMock<VconfMock>(), vconf_get_str(_))
+ .WillRepeatedly(Return(lang));
char *path = NULL;
"org.tizen.gallery.widget", WIDGET_SIZE_TYPE_4x4);
auto p = std::unique_ptr<char, decltype(std::free)*>(path, std::free);
ASSERT_STREQ(p.get(), ".//shared/res/preview_gallery_4x4.png");
+
+ // For code coverage
+ path = widget_service_get_preview_image_path(
+ NULL, WIDGET_SIZE_TYPE_4x4);
+ ASSERT_EQ(path, nullptr);
+
+ path = widget_service_get_preview_image_path(
+ "org.tizen.gallery.widget", WIDGET_SIZE_TYPE_4x4);
+ ASSERT_EQ(path, nullptr);
}
TEST_F(WidgetServiceTest, GetIcon) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
- .WillRepeatedly(Invoke(__fake_cynara_initialize));
+ .Times(2)
+ .WillOnce(Invoke(__fake_cynara_initialize))
+ .WillOnce(Return(1));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
.WillRepeatedly(Invoke(__fake_cynara_check));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
path = widget_service_get_icon("org.tizen.gallery_common", "");
auto p = std::unique_ptr<char, decltype(std::free)*>(path, std::free);
ASSERT_STREQ(p.get(), ".//shared/res/preview_gallery_4x4.png");
+
+ // For code coverage
+ path = widget_service_get_icon(NULL, "");
+ ASSERT_EQ(path, nullptr);
+
+ path = widget_service_get_icon("org.tizen.gallery_common", "");
+ ASSERT_EQ(path, nullptr);
}
TEST_F(WidgetServiceTest, GetNodisplay) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
- .WillRepeatedly(Invoke(__fake_cynara_initialize));
+ .Times(2)
+ .WillOnce(Invoke(__fake_cynara_initialize))
+ .WillOnce(Return(1));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
.WillRepeatedly(Invoke(__fake_cynara_check));
EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
ret = widget_service_get_nodisplay("org.tizen.gallery.widget");
ASSERT_EQ(ret, 0);
+
+ //For code coverage
+ ret = widget_service_get_nodisplay(NULL);
+ ASSERT_EQ(ret, 0);
+
+ ret = widget_service_get_nodisplay("org.tizen.gallery.widget");
+ ASSERT_EQ(ret, 0);
}
TEST_F(WidgetServiceTest, GetSupportedSizes) {
free(h);
}
+TEST_F(WidgetServiceTest, GetSupportedSizes_N) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
+ .WillRepeatedly(Invoke(__fake_cynara_initialize));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
+ .WillRepeatedly(Invoke(__fake_cynara_check));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
+ .WillRepeatedly(Invoke(__fake_cynara_finish));
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+
+ int ret;
+ int cnt = 10;
+ int *w;
+ int *h;
+
+ ret = widget_service_get_supported_sizes("org.tizen.gallery.widget_invalid", &cnt, &w, &h);
+ ASSERT_EQ(ret, WIDGET_ERROR_NOT_EXIST);
+}
+
TEST_F(WidgetServiceTest, GetSupportedSizeTypes) {
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
free(types);
}
+TEST_F(WidgetServiceTest, GetSupportedSizeTypes_N1) {
+ EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
+ .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_initialize(_, _))
+ .WillRepeatedly(Invoke(__fake_cynara_initialize));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_check(_, _, _, _, _))
+ .WillRepeatedly(Invoke(__fake_cynara_check));
+ EXPECT_CALL(GetMock<CynaraMock>(), cynara_finish(_))
+ .WillRepeatedly(Invoke(__fake_cynara_finish));
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+
+ int ret;
+ int cnt = 10;
+ int *types;
+
+ ret = widget_service_get_supported_size_types("org.tizen.gallery.widget_invalid", &cnt, &types);
+ ASSERT_EQ(ret, WIDGET_ERROR_NONE);
+}
+
+TEST_F(WidgetServiceTest, GetSupportedSizeTypes_N2) {
+ int ret;
+ int *types;
+
+ ret = widget_service_get_supported_size_types("org.tizen.gallery.widget_invalid", NULL, &types);
+ ASSERT_EQ(ret, WIDGET_ERROR_INVALID_PARAMETER);
+}
+
static int _widget_instance_list_cb(const char *widget_id, const char *instance_id, void *user_data) {
return 0;
}
return 0;
}
-TEST_F(WidgetServiceTest, SetLifecycleEventCb) {
+TEST_F(WidgetServiceTest, SetUnsetLifecycleEventCb) {
+ bundle *b = bundle_create();
+ int status = WIDGET_INSTANCE_EVENT_APP_RESTART_REQUEST;
+ bundle_add_str(b, AUL_K_WIDGET_ID, "org.tizen.gallery.widget");
+ bundle_add_str(b, AUL_K_COM_SENDER_PID, "100");
+ bundle_add_byte(b, AUL_K_WIDGET_STATUS, &status, sizeof(int));
+ bundle_add_str(b, AUL_K_PKGID, "sender");
+ EXPECT_CALL(GetMock<AulMock>(), aul_app_com_create(_, _, _, _, _))
+ .WillOnce(DoAll(InvokeArgument<2>("end", AUL_APP_COM_R_OK, b, nullptr),
+ Return(0)));
+ EXPECT_CALL(GetMock<AulMock>(), aul_app_get_pkgid_bypid(_, _, _))
+ .WillOnce(Invoke([](int pid, char* pkgid, int len) -> int {
+ snprintf(pkgid, len, "%s", "sender");
+ return 0;
+ }));
+
EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
.WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
ret = widget_service_set_lifecycle_event_cb("org.tizen.gallery.widget",
_widget_lifecycle_event_cb, NULL);
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
-}
-
-
-TEST_F(WidgetServiceTest, UnsetLifecycleEventCb) {
- EXPECT_CALL(GetMock<SystemInfoMock>(), system_info_get_platform_bool(_, _))
- .WillRepeatedly(Invoke(__fake_system_info_get_platform_bool));
-
- int ret;
-
+ ret = widget_service_set_lifecycle_event_cb("org.tizen.gallery.widget2",
+ _widget_lifecycle_event_cb, NULL);
+ ASSERT_EQ(ret, WIDGET_ERROR_NONE);
ret = widget_service_unset_lifecycle_event_cb("org.tizen.gallery.widget", NULL);
ASSERT_EQ(ret, WIDGET_ERROR_NONE);
+ bundle_free(b);
}
TEST_F(WidgetServiceTest, GetContent) {
using ::testing::_;
using ::testing::DoAll;
using ::testing::Invoke;
-using ::testing::SetArgPointee;
+using ::testing::InvokeArgument;
using ::testing::Return;
namespace {
return ".widget_test.db";
}
+char *instance_id = NULL;
static int __pid = 77;
int __fake_aul_launch_app_async(const char *appid, bundle *kb) {
return __pid;
}
-int __fake_aul_app_com_create(const char *endpoint, aul_app_com_permission_h permission,
- app_com_cb callback, void *user_data, aul_app_com_connection_h *connection) {
- static int __not_null;
- *connection = (aul_app_com_connection_h)&__not_null;
- return 0;
-}
-
int __fake_aul_app_com_leave(aul_app_com_connection_h connection) {
return 0;
}
};
TEST_F(WidgetInstanceTest, InstanceInit) {
+ bundle *b = bundle_create();
+ int status = WIDGET_INSTANCE_EVENT_APP_RESTART_REQUEST;
+ bundle_add_str(b, AUL_K_WIDGET_ID, "org.tizen.gallery.widget");
+ bundle_add_str(b, AUL_K_COM_SENDER_PID, "100");
+ bundle_add_byte(b, AUL_K_WIDGET_STATUS, &status, sizeof(int));
+
EXPECT_CALL(GetMock<AulMock>(), aul_app_com_create(_, _, _, _, _))
- .WillRepeatedly(Invoke(__fake_aul_app_com_create));
+ .WillOnce(DoAll(InvokeArgument<2>("end", AUL_APP_COM_R_OK, b, nullptr),
+ Return(0)));
int ret;
ret = widget_instance_init("org.tizen.gallery.widget");
ASSERT_EQ(ret, 0);
+ bundle_free(b);
}
-char *instance_id = NULL;
-
TEST_F(WidgetInstanceTest, InstanceCreate) {
EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
.WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
ASSERT_EQ(ret, 0);
}
+TEST_F(WidgetInstanceTest, InstanceInit2) {
+ bundle *b = bundle_create();
+ int status = WIDGET_INSTANCE_EVENT_CREATE;
+ bundle_add_str(b, AUL_K_WIDGET_ID, "org.tizen.gallery.widget");
+ bundle_add_byte(b, AUL_K_WIDGET_STATUS, &status, sizeof(int));
+ bundle_add_str(b, AUL_K_WIDGET_INSTANCE_ID, instance_id);
+ bundle_add_str(b, WIDGET_K_CONTENT_INFO, "cont_info");
+ bundle_add_str(b, AUL_K_WIDGET_ERROR_CODE, "13");
+
+ bundle *b2 = bundle_dup(b);
+ int status2 = WIDGET_INSTANCE_EVENT_TERMINATE;
+ bundle_del(b2, AUL_K_WIDGET_STATUS);
+ bundle_add_byte(b2, AUL_K_WIDGET_STATUS, &status2, sizeof(int));
+
+ bundle *b4 = bundle_dup(b);
+ int status4 = WIDGET_INSTANCE_EVENT_FAULT;
+ bundle_del(b4, AUL_K_WIDGET_STATUS);
+ bundle_add_byte(b4, AUL_K_WIDGET_STATUS, &status4, sizeof(int));
+
+ bundle *b5 = bundle_dup(b);
+ int status5 = WIDGET_INSTANCE_EVENT_EXTRA_UPDATED;
+ bundle_del(b5, AUL_K_WIDGET_STATUS);
+ bundle_add_byte(b5, AUL_K_WIDGET_STATUS, &status5, sizeof(int));
+
+ EXPECT_CALL(GetMock<AulMock>(), aul_app_com_create(_, _, _, _, _))
+ .WillOnce(DoAll(InvokeArgument<2>("end", AUL_APP_COM_R_OK, b, nullptr),
+ InvokeArgument<2>("end", AUL_APP_COM_R_OK, b2, nullptr),
+ InvokeArgument<2>("end", AUL_APP_COM_R_OK, b4, nullptr),
+ InvokeArgument<2>("end", AUL_APP_COM_R_OK, b5, nullptr),
+ Return(0)));
+
+ int ret;
+
+ ret = widget_instance_init("org.tizen.gallery.widget");
+ ASSERT_EQ(ret, 0);
+ bundle_free(b);
+ bundle_free(b2);
+ bundle_free(b4);
+ bundle_free(b5);
+}
+
TEST_F(WidgetInstanceTest, InstanceLaunch) {
EXPECT_CALL(GetMock<AulMock>(), aul_launch_app_async(_, _))
.WillRepeatedly(Invoke(__fake_aul_launch_app_async));
}
TEST_F(WidgetInstanceTest, InstanceListenStatus) {
-
- EXPECT_CALL(GetMock<AulMock>(), aul_app_com_create(_, _, _, _, _))
- .WillRepeatedly(Invoke(__fake_aul_app_com_create));
-
- int ret = 0;
-
+ int ret;
ret = widget_instance_listen_status("org.tizen.gallery.widget",
_widget_instance_event_cb, NULL);
ASSERT_EQ(ret, 0);
bundle_free(b);
}
-TEST_F(WidgetInstanceTest, InstanceRefUnref) {
- widget_instance_h instance = nullptr;
-
- instance = widget_instance_ref(ins);
- ASSERT_NE(instance, nullptr);
-
- widget_instance_unref(instance);
-}
-
TEST_F(WidgetInstanceTest, InstanceTerminate) {
EXPECT_CALL(GetMock<AulMock>(), aul_launch_app_async(_, _))
.WillRepeatedly(Invoke(__fake_aul_launch_app_async));
ret = widget_instance_fini();
ASSERT_EQ(ret, 0);
+}
+
+TEST_F(WidgetInstanceTest, InstanceDel_N) {
+ int ret = 0;
+
+ ret = widget_instance_delete("org.tizen.gallery.widget", instance_id);
+ ASSERT_NE(ret, WIDGET_ERROR_NONE);
+}
+
+TEST_F(WidgetInstanceTest, InstanceRefUnref) {
+ widget_instance_h instance = nullptr;
+
+ instance = widget_instance_ref(ins);
+ ASSERT_NE(instance, nullptr);
+
+ widget_instance_unref(instance);
+ widget_instance_unref(instance);
+ widget_instance_unref(instance);
}
\ No newline at end of file
projects / platform / core / appfw / widget-service.git / commitdiff