From 44cbed62f18c39ef0ddadabf9ccf9c2e2cd28af5 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 23 Nov 2017 14:39:47 +0900 Subject: [PATCH 01/16] server: correct wrong freeing Change-Id: I60595fa61f80ada4c4f2586eef8537cf38c04446 --- src/tdm_server.c | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/tdm_server.c b/src/tdm_server.c index b193ac6..b11911d 100644 --- a/src/tdm_server.c +++ b/src/tdm_server.c @@ -87,6 +87,7 @@ typedef struct _tdm_server_client_info { struct list_head link; pid_t pid; char name[TDM_NAME_LEN]; + struct wl_resource *resource; } tdm_server_client_info; static tdm_private_server *keep_private_server; @@ -700,15 +701,12 @@ destroy_client(struct wl_resource *resource) { tdm_server_client_info *c = NULL, *cc = NULL; struct wl_client *client; - pid_t pid = -1; client = wl_resource_get_client(resource); TDM_RETURN_IF_FAIL(client != NULL); - wl_client_get_credentials(client, &pid, NULL, NULL); - LIST_FOR_EACH_ENTRY_SAFE(c, cc, &client_list, link) { - if (c->pid == pid) { + if (c->resource == resource) { LIST_DEL(&c->link); free(c); return; @@ -736,6 +734,8 @@ _tdm_server_bind(struct wl_client *client, void *data, return; } + cinfo->resource = resource; + LIST_ADDTAIL(&cinfo->link, &client_list); wl_client_get_credentials(client, &cinfo->pid, NULL, NULL); _tdm_server_get_process_name(cinfo->pid, cinfo->name, TDM_NAME_LEN); @@ -907,14 +907,13 @@ tdm_server_deinit(tdm_private_loop *private_loop) wl_resource_destroy(o->resource); } + LIST_FOR_EACH_ENTRY_SAFE(c, cc, &client_list, link) { + wl_resource_destroy(c->resource); + } + free(private_server); private_loop->private_server = NULL; keep_private_server = NULL; - - LIST_FOR_EACH_ENTRY_SAFE(c, cc, &client_list, link) { - LIST_DEL(&c->link); - free(c); - } } INTERN const char* -- 2.7.4 From b11875cea5d971ff50a8c574811456bfd17a5e17 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 23 Nov 2017 15:45:16 +0900 Subject: [PATCH 02/16] ttrace: enhance -ttrace_vblank option Change-Id: Ic3afb55d3b7cf06e8962bea0ee0f71322fc06d27 --- client/tdm_client.c | 21 ++++++++++++++--- protocol/tdm.xml | 4 ++++ src/tdm.c | 58 ++++++++++++++++++++++++++++----------------- src/tdm_monitor_server.c | 61 +++++++++++++++++++++++++++++------------------- src/tdm_private.h | 6 +++++ src/tdm_server.c | 44 +++++++++++++++++++++++++++++++--- src/tdm_vblank.c | 4 ---- 7 files changed, 142 insertions(+), 56 deletions(-) diff --git a/client/tdm_client.c b/client/tdm_client.c index 267854b..e576c3d 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -92,6 +92,7 @@ struct _tdm_private_client_vblank { unsigned int fps; int offset; unsigned int enable_fake; + unsigned int enable_ttrace; unsigned int started; unsigned int stamp; @@ -153,7 +154,8 @@ _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank, if (w->req_id != req_id) continue; - TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); + if (private_vblank->enable_ttrace) + TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); if (w->req_time >= private_vblank->last_time) TDM_WRN("'req(%.6f) < last(%.6f)' failed", w->req_time, private_vblank->last_time); @@ -170,9 +172,20 @@ _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank, } } +static void +_tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable) +{ + tdm_private_client_vblank *private_vblank = data; + + TDM_RETURN_IF_FAIL(private_vblank != NULL); + + private_vblank->enable_ttrace = enable; +} + static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = { _tdm_client_vblank_cb_stamp, _tdm_client_vblank_cb_done, + _tdm_client_vblank_cb_ttrace, }; static void @@ -889,7 +902,8 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec); - TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); + if (private_vblank->enable_ttrace) + TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)", vblank, interval, w->req_id, w->req_time); @@ -973,7 +987,8 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec); - TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); + if (private_vblank->enable_ttrace) + TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp); TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)", vblank, sequence, w->req_id, w->req_time); diff --git a/protocol/tdm.xml b/protocol/tdm.xml index 0947115..24c603e 100644 --- a/protocol/tdm.xml +++ b/protocol/tdm.xml @@ -86,6 +86,10 @@ + + + + diff --git a/src/tdm.c b/src/tdm.c index 53732ac..7c36041 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -201,6 +201,13 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) _pthread_mutex_lock(&private_display->lock); } + if (private_output->ttrace_vblank) { + /* tdm_vblank APIs is for server. it should be called in unlock status*/ + _pthread_mutex_unlock(&private_display->lock); + tdm_vblank_destroy(private_output->ttrace_vblank); + _pthread_mutex_lock(&private_display->lock); + } + LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_output->capture_list, link) tdm_capture_destroy_internal(c); @@ -1281,14 +1288,13 @@ tdm_display_enable_path(const char *path) return TDM_ERROR_NONE; } - static void _tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { tdm_error ret = TDM_ERROR_NONE; - TDM_TRACE_MARK("TDM_DISPLAY_TTRACE_VBlank"); + TDM_TRACE_MARK("VSYNC"); ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL); TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); @@ -1297,42 +1303,50 @@ _tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int INTERN tdm_error tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable) { - static tdm_vblank *vblank = NULL; + tdm_private_display *private_display = dpy; + tdm_private_output *private_output = NULL; + const tdm_output_mode *mode = NULL; + tdm_vblank *vblank = NULL; tdm_error ret = TDM_ERROR_NONE; if (!enable) { - if (vblank) - tdm_vblank_destroy(vblank); - vblank = NULL; + LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) { + if (private_output->ttrace_vblank) + tdm_vblank_destroy(private_output->ttrace_vblank); + private_output->ttrace_vblank = NULL; + } return TDM_ERROR_NONE; - } else { - const tdm_output_mode *mode = NULL; + } - if (vblank) - return TDM_ERROR_NONE; + private_output = output; + TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER); - vblank = tdm_vblank_create(dpy, output, &ret); - TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret); + if (private_output->ttrace_vblank) + return TDM_ERROR_NONE; - ret = tdm_output_get_mode(output, &mode); - TDM_GOTO_IF_FAIL(mode != NULL, enable_fail); + vblank = tdm_vblank_create(private_display, output, &ret); + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret); - ret = tdm_vblank_set_fps(vblank, mode->vrefresh); - TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); + ret = tdm_output_get_mode(output, &mode); + TDM_GOTO_IF_FAIL(mode != NULL, enable_fail); - ret = tdm_vblank_set_enable_fake(vblank, 1); - TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); + ret = tdm_vblank_set_fps(vblank, mode->vrefresh); + TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); - ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL); - TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); - } + ret = tdm_vblank_set_enable_fake(vblank, 1); + TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); + + ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL); + TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); + + private_output->ttrace_vblank = vblank; return TDM_ERROR_NONE; enable_fail: if (vblank) tdm_vblank_destroy(vblank); - vblank = NULL; + return ret; } diff --git a/src/tdm_monitor_server.c b/src/tdm_monitor_server.c index 07c2487..0d92cef 100644 --- a/src/tdm_monitor_server.c +++ b/src/tdm_monitor_server.c @@ -108,12 +108,9 @@ _tdm_monitor_server_dpms(unsigned int pid, char *cwd, int argc, char *argv[], ch static void _tdm_monitor_server_ttrace_vblank(unsigned int pid, char *cwd, int argc, char *argv[], char *reply, int *len, tdm_display *dpy) { - int enable, output_id = 0; - tdm_output *output; + int ttrace_vblank, output_id = 0; char *arg; char *end; - tdm_error ret; - tdm_output_type type; if (argc < 3) { _tdm_monitor_server_usage(argv[0], reply, len); @@ -121,29 +118,45 @@ _tdm_monitor_server_ttrace_vblank(unsigned int pid, char *cwd, int argc, char *a } arg = argv[2]; - enable = strtol(arg, &end, 10); + ttrace_vblank = strtol(arg, &end, 10); - if (*end == '@') { - arg = end + 1; - output_id = strtol(arg, &end, 10); - } + if (ttrace_vblank > 0) { + tdm_output *output; + tdm_error ret; + tdm_output_type type; + char *temp; - output = tdm_display_get_output(dpy, output_id, NULL); - if (!output) { - TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id); - return; - } + if (*end == '@') { + arg = end + 1; + output_id = strtol(arg, &end, 10); + } - ret = tdm_output_get_output_type(output, &type); - if (ret != TDM_ERROR_NONE) { - TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id); - return; - } + output = tdm_display_get_output(dpy, output_id, NULL); + if (!output) { + TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id); + return; + } - tdm_display_enable_ttrace_vblank(dpy, output, enable); + ret = tdm_output_get_output_type(output, &type); + if (ret != TDM_ERROR_NONE) { + TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id); + return; + } - TDM_SNPRINTF(reply, len, "%s ttrace vblank for '%s'\n", - (enable) ? "enable" : "disable", tdm_conn_str(type)); + temp = "server"; + tdm_display_enable_ttrace_vblank(dpy, output, 1); + + if (ttrace_vblank > 1) { + temp = "clients"; + tdm_server_enable_ttrace_vblank(dpy, output, 1); + } + + TDM_SNPRINTF(reply, len, "enable ttrace vblank for '%s': %s \n", tdm_conn_str(type), temp); + } else { + tdm_display_enable_ttrace_vblank(dpy, NULL, 0); + tdm_server_enable_ttrace_vblank(dpy, NULL, 0); + TDM_SNPRINTF(reply, len, "disable ttrace vblank\n"); + } } static void @@ -534,8 +547,8 @@ static struct { }, { "ttrace_vblank", _tdm_monitor_server_ttrace_vblank, - "enable/disable the vblank for ttrace [0:disable 1:enable]", - "[@]", "0 or 1" + "enable/disable the vblank for ttrace [0:disable, 1:server, 2:clients]", + "[@]", "0 or 1 or 2 or 1@0 or 2@0 or 1@1 or 2@1" }, { "debug", _tdm_monitor_server_debug, diff --git a/src/tdm_private.h b/src/tdm_private.h index 92bb4a1..5e63e5c 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -235,6 +235,10 @@ struct _tdm_private_output { /* calling a output commit per a vblank */ int commit_per_vblank; tdm_commit_type commit_type; + + /* for ttrace vblank */ + tdm_vblank *ttrace_vblank; + unsigned int ttrace_vblank_client; }; struct _tdm_private_layer { @@ -653,6 +657,8 @@ void tdm_server_deinit(tdm_private_loop *private_loop); const char* tdm_server_get_client_name(pid_t pid); +tdm_error +tdm_server_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable); char * tdm_helper_dump_make_directory(const char *path, char *reply, int *len); diff --git a/src/tdm_server.c b/src/tdm_server.c index b11911d..f56b1ad 100644 --- a/src/tdm_server.c +++ b/src/tdm_server.c @@ -88,6 +88,7 @@ typedef struct _tdm_server_client_info { pid_t pid; char name[TDM_NAME_LEN]; struct wl_resource *resource; + tdm_private_server *private_server; } tdm_server_client_info; static tdm_private_server *keep_private_server; @@ -167,6 +168,7 @@ _tdm_server_send_done(tdm_server_wait_info *wait_info, tdm_error error, { tdm_server_wait_info *found; tdm_server_vblank_info *vblank_info; + tdm_private_output *private_output; if (!keep_private_server) return; @@ -185,7 +187,9 @@ _tdm_server_send_done(tdm_server_wait_info *wait_info, tdm_error error, wl_tdm_vblank_send_done(vblank_info->resource, wait_info->req_id, sequence, tv_sec, tv_usec, error); - TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp); + private_output = vblank_info->output_info->output; + if (private_output->ttrace_vblank_client) + TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp); destroy_wait(wait_info); } @@ -304,6 +308,7 @@ _tdm_server_vblank_cb_wait_vblank(struct wl_client *client, struct wl_resource * tdm_server_vblank_info *vblank_info = wl_resource_get_user_data(resource); tdm_server_output_info *output_info = vblank_info->output_info; tdm_private_server *private_server = output_info->private_server; + tdm_private_output *private_output = output_info->output; tdm_server_wait_info *wait_info; unsigned int enable_fake = 0; tdm_error ret; @@ -323,7 +328,9 @@ _tdm_server_vblank_cb_wait_vblank(struct wl_client *client, struct wl_resource * if (tdm_debug_module & TDM_DEBUG_VBLANK) TDM_DBG("req_id(%d) wait", req_id); - TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp); + private_output = vblank_info->output_info->output; + if (private_output->ttrace_vblank_client) + TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp); ret = tdm_vblank_wait(vblank_info->vblank, req_sec, req_usec, interval, _tdm_server_cb_vblank, wait_info); @@ -347,6 +354,7 @@ _tdm_server_vblank_cb_wait_vblank_seq(struct wl_client *client, struct wl_resour tdm_server_vblank_info *vblank_info = wl_resource_get_user_data(resource); tdm_server_output_info *output_info = vblank_info->output_info; tdm_private_server *private_server = output_info->private_server; + tdm_private_output *private_output = output_info->output; tdm_server_wait_info *wait_info; unsigned int enable_fake = 0; tdm_error ret; @@ -366,7 +374,9 @@ _tdm_server_vblank_cb_wait_vblank_seq(struct wl_client *client, struct wl_resour if (tdm_debug_module & TDM_DEBUG_VBLANK) TDM_DBG("req_id(%d) wait", req_id); - TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp); + private_output = vblank_info->output_info->output; + if (private_output->ttrace_vblank_client) + TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Server_Vblank:%u", vblank_info->stamp); ret = tdm_vblank_wait_seq(vblank_info->vblank, req_sec, req_usec, sequence, _tdm_server_cb_vblank, wait_info); @@ -735,6 +745,7 @@ _tdm_server_bind(struct wl_client *client, void *data, } cinfo->resource = resource; + cinfo->private_server = data; LIST_ADDTAIL(&cinfo->link, &client_list); wl_client_get_credentials(client, &cinfo->pid, NULL, NULL); @@ -928,3 +939,30 @@ tdm_server_get_client_name(pid_t pid) return NULL; } + +INTERN tdm_error +tdm_server_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable) +{ + tdm_server_client_info *cinfo = NULL; + + LIST_FOR_EACH_ENTRY(cinfo, &client_list, link) { + tdm_private_server *private_server = cinfo->private_server; + tdm_server_output_info *output_info = NULL; + + LIST_FOR_EACH_ENTRY(output_info, &private_server->output_list, link) { + tdm_server_vblank_info *vblank_info = NULL; + tdm_private_output *private_output = output_info->output; + + if (output && output_info->output != output) + continue; + + private_output->ttrace_vblank_client = enable; + + LIST_FOR_EACH_ENTRY(vblank_info, &output_info->vblank_list, link) { + wl_tdm_vblank_send_ttrace(vblank_info->resource, enable); + } + } + } + + return TDM_ERROR_NONE; +} diff --git a/src/tdm_vblank.c b/src/tdm_vblank.c index 1a3f6b9..462eaf5 100644 --- a/src/tdm_vblank.c +++ b/src/tdm_vblank.c @@ -771,8 +771,6 @@ _tdm_vblank_cb_vblank_HW(tdm_output *output, unsigned int sequence, return; } - TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_HW_Vblank:%u", (unsigned int)private_vblank->stamp); - if (wait_info->type == VBLANK_TYPE_HW_SW) { tdm_error ret; @@ -883,8 +881,6 @@ _tdm_vblank_wait_HW(tdm_vblank_wait_info *wait_info) skip, hw_interval, wait_info->target_seq); } - TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_HW_Vblank:%u", (unsigned int)private_vblank->stamp); - if (private_vblank->add_front) ret = tdm_output_wait_vblank_add_front(private_vblank->output, hw_interval, 0, _tdm_vblank_cb_vblank_HW, wait_info); -- 2.7.4 From caf262bfa1dbff0709afca62bfb7a735f10492fa Mon Sep 17 00:00:00 2001 From: Andrii Sokolenko Date: Thu, 23 Nov 2017 09:46:54 +0200 Subject: [PATCH 03/16] utest: Fix warning of incorrect type casting Change-Id: I8f8654f2f1e170ae539e417649b7c5b3dc035786 Signed-off-by: Andrii Sokolenko --- utests/src/ut_tdm_buffer.cpp | 12 ++++++------ utests/src/ut_tdm_output.cpp | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/utests/src/ut_tdm_buffer.cpp b/utests/src/ut_tdm_buffer.cpp index 7efba7b..c7b8029 100644 --- a/utests/src/ut_tdm_buffer.cpp +++ b/utests/src/ut_tdm_buffer.cpp @@ -14,7 +14,7 @@ extern "C" { class TDMBuffer: public ::testing::Test { protected: - static tbm_bufmgr tbm_bufmgr; + static tbm_bufmgr tbm_bufmgr_s; static int master_fd; tbm_surface_h surface; @@ -42,15 +42,15 @@ protected: static void SetUpTestCase() { SetEnv(); - tbm_bufmgr = tbm_bufmgr_init(-1); - ASSERT_FALSE(tbm_bufmgr == NULL); + tbm_bufmgr_s = tbm_bufmgr_init(-1); + ASSERT_FALSE(tbm_bufmgr_s == NULL); master_fd = tbm_drm_helper_get_master_fd(); } static void TearDownTestCase() { - tbm_bufmgr_deinit(tbm_bufmgr); - tbm_bufmgr = NULL; + tbm_bufmgr_deinit(tbm_bufmgr_s); + tbm_bufmgr_s = NULL; if (master_fd > -1) { int temp_master_fd = tbm_drm_helper_get_master_fd(); @@ -76,7 +76,7 @@ protected: } }; -tbm_bufmgr TDMBuffer::tbm_bufmgr = NULL; +tbm_bufmgr TDMBuffer::tbm_bufmgr_s = NULL; int TDMBuffer::master_fd = -42; diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index 9c050ba..effb32f 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -109,7 +109,7 @@ class TDMOutputCommit : public TDMOutput { protected: int conn_output_count = 0; tdm_output ** connected_output_array = NULL; - tdm_output_mode** preferred_mode = NULL; + const tdm_output_mode** preferred_mode = NULL; bool has_output = false; void SetUp(void) { @@ -117,7 +117,7 @@ protected: if (TDMOutput::output_count > 0) { connected_output_array = (tdm_output **) calloc(TDMOutput::output_count, sizeof(tdm_output *)); ASSERT_FALSE(NULL == connected_output_array); - preferred_mode = (tdm_output_mode **) calloc(TDMOutput::output_count, sizeof(tdm_output_mode*)); + preferred_mode = (const tdm_output_mode **) calloc(TDMOutput::output_count, sizeof(tdm_output_mode*)); ASSERT_FALSE(NULL == preferred_mode); } conn_output_count = 0; -- 2.7.4 From 9b4982861aa04c005d07c1ad31d1463db5099f56 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 24 Nov 2017 10:37:48 +0900 Subject: [PATCH 04/16] add -Werror to CXXFLAGS Change-Id: I98d88aa39b9d46f517f2cbf44366044909111253 --- packaging/libtdm.spec | 1 + 1 file changed, 1 insertion(+) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 6e68d87..204eeae 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -76,6 +76,7 @@ UTEST="yes" %reconfigure --disable-static --with-utests=${UTEST} \ CFLAGS="${CFLAGS} -Wall -Werror" \ + CXXFLAGS="${CXXFLAGS} -Wall -Werror" \ LDFLAGS="${LDFLAGS} -Wl,--hash-style=both -Wl,--as-needed" make %{?_smp_mflags} -- 2.7.4 From ae9a734369399e20b58e24975bb684c5d0342e53 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 24 Nov 2017 10:54:24 +0900 Subject: [PATCH 05/16] package version up to 1.8.4 Change-Id: Ic1b66478ff6342e1212a2e2e730da3cc1a7c2de7 --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 204eeae..f83d628 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -1,7 +1,7 @@ %define UTEST_PACKAGE 1 Name: libtdm -Version: 1.8.3 +Version: 1.8.4 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 90e2df166ab7944e5ff22513dce956fd6590a517 Mon Sep 17 00:00:00 2001 From: Roman Marchenko Date: Thu, 23 Nov 2017 14:20:19 +0200 Subject: [PATCH 06/16] hwc: add TDM_COMPOSITION_NONE use TDM_COMPOSITION_NONE insted TDM_HWC_WINDOW_FLAG_SKIP Change-Id: I8e1959cd953dc38e9dc77ce6c5193659cc8e838c --- include/tdm_common.h | 2 +- include/tdm_types.h | 20 ++++++++++++++------ 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/include/tdm_common.h b/include/tdm_common.h index 84549f3..637d883 100644 --- a/include/tdm_common.h +++ b/include/tdm_common.h @@ -306,7 +306,7 @@ typedef union { * @since 2.0.0 */ typedef enum { - TDM_HWC_WINDOW_FLAG_SKIP = (1 << 0), + TDM_HWC_WINDOW_FLAG_NONE = 0, } tdm_hwc_window_flag; #ifdef __cplusplus diff --git a/include/tdm_types.h b/include/tdm_types.h index 58a787f..626c1c3 100644 --- a/include/tdm_types.h +++ b/include/tdm_types.h @@ -143,6 +143,13 @@ typedef struct _tdm_info_capture { * @since 2.0.0 */ typedef enum { + + /** Set by the client for an invisible window. The value by default. + * + * The device ignores windows of this type. + */ + TDM_COMPOSITION_NONE = 0, + /** The client will composite this window into the client target window * * User can choose this type for window to avoid a hardware composition for @@ -154,7 +161,7 @@ typedef enum { * The device must not request any composition type changes for windows of * this type. */ - TDM_COMPOSITION_CLIENT = 0, + TDM_COMPOSITION_CLIENT = 1, /* Set by the HWC after tdm_output_hwc_validate(). * @@ -187,13 +194,14 @@ typedef enum { * window to the TDM_COMPOSITION_CLIENT type, it causes a type of this window being changed * to TDM_COMPOSITION_CLIENT. */ - TDM_COMPOSITION_CLIENT_CANDIDATE = 5, + TDM_COMPOSITION_CLIENT_CANDIDATE = 2, + /** Set by the client before tdm_output_hwc_validate(). * * Upon tdm_output_hwc_validate(), the device may request a change from this type to * TDM_COMPOSITION_DEVICE or TDM_COMPOSITION_CLIENT. */ - TDM_COMPOSITION_DEVICE_CANDIDATE = 2, + TDM_COMPOSITION_DEVICE_CANDIDATE = 3, /** Set by the HWC after tdm_output_hwc_validate(). * @@ -202,7 +210,7 @@ typedef enum { * * Upon tdm_output_hwc_validate(), the device may request a change from this type to * TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE. */ - TDM_COMPOSITION_DEVICE = 1, + TDM_COMPOSITION_DEVICE = 4, /** Similar to DEVICE, but the position of this layer may also be set * asynchronously through layer_set_cursor_position. If this functionality is not @@ -214,7 +222,7 @@ typedef enum { * either TDM_COMPOSITION_DEVICE or TDM_COMPOSITION_CLIENT. Changing to * TDM_COMPOSITION_DEVICE will prevent the use of layer_set_cursor_position but * still permit the device to composite the layer. */ - TDM_COMPOSITION_CURSOR = 3, + TDM_COMPOSITION_CURSOR = 5, /** The device will handle the composition of this layer through a hardware * overlay or other similar means. @@ -222,7 +230,7 @@ typedef enum { * Upon tdm_output_hwc_validate(), the device may request a change from this type to * either TDM_COMPOSITION_DEVICE or TDM_COMPOSITION_CLIENT, but it is * unlikely that content will display correctly in these cases. */ - TDM_COMPOSITION_VIDEO = 4, + TDM_COMPOSITION_VIDEO = 6, } tdm_hwc_window_composition; /** -- 2.7.4 From c0c6fbadf2524cbffadaa6928e0d94a72b0325f0 Mon Sep 17 00:00:00 2001 From: Roman Marchenko Date: Thu, 23 Nov 2017 17:07:55 +0200 Subject: [PATCH 07/16] utest: Add 33 tests cases for tdm_helper Change-Id: I7b3d77866a67d45ffa740456351629d3cc85f148 Signed-off-by: Roman Marchenko --- utests/Makefile.am | 1 + utests/src/ut_tdm_helper.cpp | 587 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 588 insertions(+) create mode 100644 utests/src/ut_tdm_helper.cpp diff --git a/utests/Makefile.am b/utests/Makefile.am index b919431..eee9511 100644 --- a/utests/Makefile.am +++ b/utests/Makefile.am @@ -8,6 +8,7 @@ tdm_utests_SOURCES = \ src/ut_tdm_output.cpp \ src/ut_tdm_hwc_window.cpp \ src/ut_tdm_buffer.cpp \ + src/ut_tdm_helper.cpp \ src/ut_tdm_layer.cpp \ src/ut_tdm_vblank.cpp diff --git a/utests/src/ut_tdm_helper.cpp b/utests/src/ut_tdm_helper.cpp new file mode 100644 index 0000000..917c3e3 --- /dev/null +++ b/utests/src/ut_tdm_helper.cpp @@ -0,0 +1,587 @@ +#include "gtest/gtest.h" +#include "ut_common.h" +#include "stdint.h" +#include +#include +#include + +extern "C" { +#include "tdm.h" +#include "tdm_helper.h" +#include "tdm_backend.h" +#include "tbm_bufmgr.h" +#include "tbm_surface.h" +#include "tbm_surface_internal.h" +#include "tbm_drm_helper.h" +} + +#define TMP_PATH_FOR_UTEST "tmp_utest_helper" +#define STR_LEN 8192 + +class TDMHelper : public ::testing::Test { +protected: + tdm_display *dpy = NULL; + tbm_bufmgr bufmgr = NULL; + int master_fd = -42; + /*list of connected outputs*/ + int output_count = 0; + const tdm_output_mode **preferred_mode_array = NULL; + tdm_output **outputs; + tdm_error error ; + tbm_surface_h surface; + virtual void SetEnv() + { + setenv("TDM_THREAD", "0", 1); + setenv("TDM_COMMIT_PER_VBLANK", "1", 1); + setenv("XDG_RUNTIME_DIR", ".", 1); + setenv("TBM_DISPLAY_SERVER", "1", 1); + } + + void UnsetEnv() + { + unsetenv("TDM_THREAD"); + unsetenv("TDM_COMMIT_PER_VBLANK"); + unsetenv("XDG_RUNTIME_DIR"); + unsetenv("TBM_DISPLAY_SERVER"); + } + + void SetUp(void) + { + const tdm_output_mode *preferred_mode = NULL; + tdm_error error = TDM_ERROR_NONE; + int all_output_count = 0; + + SetEnv(); + + bufmgr = tbm_bufmgr_init(-1); + ASSERT_FALSE(bufmgr == NULL); + + dpy = tdm_display_init(&error); + ASSERT_TRUE(error == TDM_ERROR_NONE); + ASSERT_FALSE(dpy == NULL); + + master_fd = tbm_drm_helper_get_master_fd(); + ASSERT_TRUE(tdm_display_get_output_count(dpy, &all_output_count) == TDM_ERROR_NONE); + + outputs = (tdm_output **)calloc(all_output_count, sizeof(tdm_output *)); + ASSERT_FALSE(NULL == outputs); + + preferred_mode_array = (const tdm_output_mode **)calloc(all_output_count, sizeof(tdm_output_mode *)); + ASSERT_FALSE(NULL == preferred_mode_array); + + output_count = 0; + + for (int i = 0; i < all_output_count; i++) { + tdm_output *output = tdm_display_get_output(dpy, i, &error); + int output_modes_cnt = 0; + const tdm_output_mode *output_modes; + + if (TDM_ERROR_NONE != error || NULL == output) + continue; + + tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED; + if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status)) + continue; + + if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) + continue; + + error = tdm_output_get_available_modes(output, &output_modes, &output_modes_cnt); + if (TDM_ERROR_NONE != error) + continue; + if (output_modes_cnt <= 0) { + continue; + } + + for(int j = 0; j < output_modes_cnt; j++) + if(output_modes[j].type & TDM_OUTPUT_MODE_TYPE_PREFERRED) + preferred_mode = &output_modes[j]; + + if (!preferred_mode) + continue; + + if (preferred_mode_array) + preferred_mode_array[output_count] = preferred_mode; + if (outputs) + outputs[output_count] = output; + output_count++; + + error = tdm_output_set_mode(output, preferred_mode); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + surface = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888); + ASSERT_TRUE(surface != NULL); + } + + void TearDown(void) + { + if (surface) { + while (tbm_surface_internal_is_valid(surface)) + tbm_surface_destroy(surface); + } + tdm_display_deinit(dpy); + dpy = NULL; + tbm_bufmgr_deinit(bufmgr); + bufmgr = NULL; + if (outputs) + free(outputs); + if (preferred_mode_array) + free(preferred_mode_array); + if (master_fd > -1) { + int temp_master_fd = tbm_drm_helper_get_master_fd(); + EXPECT_EQ(temp_master_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl; + if (temp_master_fd > -1) + exit(1); + close(master_fd); + } + + UnsetEnv(); + } +}; + +int remove_cb(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf) +{ + int rv = remove(fpath); + if (rv) + perror(fpath); + return rv; +} + +int rmrf(const char *path) +{ + return nftw(path, remove_cb, 64, FTW_DEPTH | FTW_PHYS); +} + +class TDMHelperSurface: public TDMHelper +{ +protected: + + void SetUp() + { + TDMHelper::SetUp(); + ASSERT_EQ(0, mkdir(TMP_PATH_FOR_UTEST, 0755)) << "error: " << strerror(errno); + } + void TearDown() + { + + rmrf(TMP_PATH_FOR_UTEST); + TDMHelper::TearDown(); + } +}; + +class TDMHelperDisplay: public TDMHelper { +}; + +class TDMHelperOutput: public TDMHelper { +}; + + +/* double tdm_helper_get_time(void); */ +TEST(TDMHelper, GetTime) +{ + double time; + time = tdm_helper_get_time(); + EXPECT_GT(time, 0); +} + +/* void tdm_helper_dump_start(char *dumppath, int *count); */ +TEST(TDMHelper, DumpStartFailNull) +{ + int count = 100; + tdm_helper_dump_start(NULL, &count); + + tdm_helper_dump_start((char *)TMP_PATH_FOR_UTEST, NULL); +} + +TEST(TDMHelper, DumpStartSuccessful) +{ + int count = 100; + tdm_helper_dump_start((char *)TMP_PATH_FOR_UTEST, &count); +} + +/* void tdm_helper_dump_stop(void); */ +TEST(TDMHelper, DumpStopSuccessful) +{ + tdm_helper_dump_stop(); +} + +/* void tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file); */ +TEST_F(TDMHelperSurface, DumpBufferFailNull) +{ + tdm_helper_dump_buffer(NULL, TMP_PATH_FOR_UTEST "/tmp"); +} + +TEST_F(TDMHelperSurface, DumpBufferFailInvalideOutput) +{ + int invalid_surface; + tdm_helper_dump_buffer((tbm_surface_h)&invalid_surface, TMP_PATH_FOR_UTEST "/xyz.png"); + + /* file name mast have an extension ".png" */ + tdm_helper_dump_buffer(surface, TMP_PATH_FOR_UTEST "/tmp.xyz"); +} + +TEST_F(TDMHelperSurface, DumpBufferFailUnknownFormat) +{ + tbm_surface_h surf; + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444); + ASSERT_TRUE(surf != NULL); + tdm_helper_dump_buffer(surface, TMP_PATH_FOR_UTEST "/xyz.png"); + tbm_surface_destroy(surf); +} + +TEST_F(TDMHelperSurface, DumpBufferSuccessful) +{ + tbm_surface_h surf; + + tdm_helper_dump_buffer(surface, TMP_PATH_FOR_UTEST "/rgb.png"); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV420); + ASSERT_TRUE(surf != NULL); + tdm_helper_dump_buffer(surf, TMP_PATH_FOR_UTEST "/YUV.yuv"); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12); + ASSERT_TRUE(surf != NULL); + tdm_helper_dump_buffer(surf, TMP_PATH_FOR_UTEST "/NV.yuv"); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV); + ASSERT_TRUE(surf != NULL); + tdm_helper_dump_buffer(surf, TMP_PATH_FOR_UTEST "/YUYV.yuv"); + tbm_surface_destroy(surf); +} + +/* void tdm_helper_clear_buffer_color(tbm_surface_h buffer, tdm_pos *pos, unsigned int color); */ +TEST_F(TDMHelperSurface, ClearBufferColorFailNull) +{ + tdm_pos pos; + tdm_helper_clear_buffer_color(NULL, &pos, 0x0F0F0F); +} + +TEST_F(TDMHelperSurface, ClearBufferColorInvalideOutput) +{ + int invalid_surface; + tdm_pos pos; + tdm_helper_clear_buffer_color((tbm_surface_h)&invalid_surface, &pos, 0x0F0F0F); +} + +TEST_F(TDMHelperSurface, ClearBufferColorUnknownFormat) +{ + tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 }; + tbm_surface_h surf; + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F); + tbm_surface_destroy(surf); +} + +TEST_F(TDMHelperSurface, ClearBufferColorSuccessful) +{ + tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 }; + tbm_surface_h surf; + + tdm_helper_clear_buffer_color(surface, &pos, 0x0F0F0F); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YVU420); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_UYVY); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_color(surf, &pos, 0x0F0F0F); + tbm_surface_destroy(surf); +} + +/* void tdm_helper_clear_buffer_pos(tbm_surface_h buffer, tdm_pos *pos); */ +TEST_F(TDMHelperSurface, ClearBufferPosFailNull) +{ + tdm_pos pos; + tdm_helper_clear_buffer_pos(NULL, &pos); +} + +TEST_F(TDMHelperSurface, ClearBufferPosInvalideOutput) +{ + int invalid_surface; + tdm_pos pos; + tdm_helper_clear_buffer_pos((tbm_surface_h)&invalid_surface, &pos); +} + +TEST_F(TDMHelperSurface, ClearBufferPosUnknownFormat) +{ + tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 }; + tbm_surface_h surf; + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_pos(surf, &pos); + tbm_surface_destroy(surf); +} + +TEST_F(TDMHelperSurface, ClearBufferPosSuccessful) +{ + tdm_pos pos = { .x = 0, .y = 0, .w = 10, .h = 10 }; + tbm_surface_h surf; + + tdm_helper_clear_buffer_pos(surface, &pos); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YVU420); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_pos(surf, &pos); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_pos(surf, &pos); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_pos(surf, &pos); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_UYVY); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer_pos(surf, &pos); + tbm_surface_destroy(surf); +} + +/* void tdm_helper_clear_buffer(tbm_surface_h buffer); */ +TEST_F(TDMHelperSurface, ClearBufferFailNull) +{ + tdm_helper_clear_buffer(NULL); +} + +TEST_F(TDMHelperSurface, ClearBufferInvalideOutput) +{ + int invalid_surface; + tdm_helper_clear_buffer((tbm_surface_h)&invalid_surface); +} + +TEST_F(TDMHelperSurface, ClearBufferUnknownFormat) +{ + tbm_surface_h surf; + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUV444); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer(surf); + tbm_surface_destroy(surf); +} + +TEST_F(TDMHelperSurface, ClearBufferSuccessful) +{ + tbm_surface_h surf; + + tdm_helper_clear_buffer(surface); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YVU420); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer(surf); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_NV12); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer(surf); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_YUYV); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer(surf); + tbm_surface_destroy(surf); + + surf = tbm_surface_create(256, 256, TBM_FORMAT_UYVY); + ASSERT_TRUE(surf != NULL); + tdm_helper_clear_buffer(surf); + tbm_surface_destroy(surf); +} + +/* void tdm_helper_get_buffer_full_size(tbm_surface_h buffer, int *buffer_w, int *buffer_h); */ +TEST_F(TDMHelperSurface, GetBufferFullSizeFailNull) +{ + int buffer_w; + int buffer_h; + tdm_helper_get_buffer_full_size(NULL, &buffer_w, &buffer_h); +} + +TEST_F(TDMHelperSurface, GetBufferFullSizeFailinvalidBuffer) +{ + int invalid_surface; + int buffer_w; + int buffer_h; + tdm_helper_get_buffer_full_size((tbm_surface_h)&invalid_surface, &buffer_w, &buffer_h); +} + +TEST_F(TDMHelperSurface, GetBufferFullSizeSuccessful) +{ + int buffer_w = 0; + int buffer_h = 0; + tdm_helper_get_buffer_full_size(surface, &buffer_w, &buffer_h); + ASSERT_GE(buffer_w, 0); + ASSERT_GE(buffer_h, 0); +} + +/* tdm_error tdm_helper_convert_buffer(tbm_surface_h srcbuf, tbm_surface_h dstbuf, + tdm_pos *srcpos, tdm_pos *dstpos, + tdm_transform transform, int over); */ +TEST_F(TDMHelperSurface, ConvertBufferFailNull) +{ + tdm_pos srcpos = { 0, 0, 256, 256 }; + tdm_pos dstpos = { 0, 0, 256, 256 }; + tbm_surface_h dstbuf; + tdm_error error; + + dstbuf = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888); + ASSERT_TRUE(dstbuf != NULL); + + error = tdm_helper_convert_buffer(NULL, dstbuf, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0); + tbm_surface_destroy(dstbuf); + ASSERT_NE(TDM_ERROR_NONE, error); + + error = tdm_helper_convert_buffer(surface, NULL, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_F(TDMHelperSurface, ConvertBufferFailinvalidBuffer) +{ + int invalid_surface; + tdm_pos srcpos = { 0, 0, 256, 256 }; + tdm_pos dstpos = { 0, 0, 256, 256 }; + tbm_surface_h dstbuf; + tdm_error error; + + dstbuf = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888); + ASSERT_TRUE(dstbuf != NULL); + + error = tdm_helper_convert_buffer((tbm_surface_h)&invalid_surface, dstbuf, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0); + tbm_surface_destroy(dstbuf); + ASSERT_NE(TDM_ERROR_NONE, error); + + error = tdm_helper_convert_buffer(surface, (tbm_surface_h)&invalid_surface, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_F(TDMHelperSurface, ConvertBufferSuccessful) +{ + tdm_pos srcpos = { 0, 0, 256, 256 }; + tdm_pos dstpos = { 0, 0, 256, 256 }; + tbm_surface_h dstbuf; + tdm_error error; + + dstbuf = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888); + ASSERT_TRUE(dstbuf != NULL); + + error = tdm_helper_convert_buffer(surface, dstbuf, &srcpos, &dstpos, TDM_TRANSFORM_NORMAL, 0); + tbm_surface_destroy(dstbuf); + ASSERT_EQ(TDM_ERROR_NONE, error); +} + + +/* void tdm_helper_get_display_information(tdm_display *dpy, char *reply, int *len); */ +TEST_F(TDMHelperDisplay, GetDisplayInformationFailNull) +{ + char reply[STR_LEN] = {0}; + int len = STR_LEN; + tdm_helper_get_display_information(NULL, reply, &len); + ASSERT_LT(len, STR_LEN); + ASSERT_EQ((STR_LEN - len), strlen(reply)); + + len = STR_LEN; + tdm_helper_get_display_information(dpy, NULL, &len); + ASSERT_EQ(STR_LEN, len); + + reply[0] = '\0'; + tdm_helper_get_display_information(dpy, reply, NULL); + ASSERT_EQ(0, reply[0]); +} + +TEST_F(TDMHelperDisplay, GetDisplayInformationSuccessful) +{ + char reply[STR_LEN] = {0}; + int len = STR_LEN; + tdm_helper_get_display_information(dpy, reply, &len); + ASSERT_LT(len, STR_LEN); + ASSERT_EQ((STR_LEN - len), strlen(reply)); +} +int capture_handler_is_called = 0; +void capture_handler(tbm_surface_h buffer, void *user_data) +{ + if (&capture_handler_is_called == user_data) + capture_handler_is_called = 1; +} +/* tdm_error tdm_helper_capture_output(...); */ +TEST_F(TDMHelperOutput, CaptureOutputFailNull) +{ + int output_count = 0; + tdm_output *output = NULL; + tdm_error error; + tbm_surface_h buffer = NULL; + + error = tdm_display_get_output_count(dpy, &output_count); + ASSERT_EQ(TDM_ERROR_NONE, error); + for (int i = 0; i < output_count; i++) { + + output = tdm_display_get_output(dpy, i, &error); + ASSERT_NE(NULL, output); + + error = tdm_helper_capture_output(NULL, buffer, 0, 0, 0, 0, capture_handler, &capture_handler_is_called); + ASSERT_NE(TDM_ERROR_NONE, error); + error = tdm_helper_capture_output(output, NULL, 0, 0, 0, 0, capture_handler, &capture_handler_is_called); + ASSERT_NE(TDM_ERROR_NONE, error); + error = tdm_helper_capture_output(output, buffer, 0, 0, 0, 0, NULL, &capture_handler_is_called); + ASSERT_NE(TDM_ERROR_NONE, error); + error = tdm_helper_capture_output(output, buffer, 0, 0, 0, 0, capture_handler, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +TEST_F(TDMHelperOutput, CaptureOutputFailInvalidInputs) +{ + for (int i = 0; i < output_count; i++) { + error = tdm_helper_capture_output(outputs[i], surface, -1, 0, 0, 0, capture_handler, &capture_handler_is_called); + ASSERT_NE(TDM_ERROR_NONE, error); + error = tdm_helper_capture_output(outputs[i], surface, 0, -1, 0, 0, capture_handler, &capture_handler_is_called); + ASSERT_NE(TDM_ERROR_NONE, error); + error = tdm_helper_capture_output(outputs[i], surface, 0, 0, -1, 0, capture_handler, &capture_handler_is_called); + ASSERT_NE(TDM_ERROR_NONE, error); + error = tdm_helper_capture_output(outputs[i], surface, 0, 0, 0, -1, capture_handler, &capture_handler_is_called); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +TEST_F(TDMHelperOutput, CaptureOutputSuccessful) +{ + error = tdm_display_get_output_count(dpy, &output_count); + ASSERT_EQ(TDM_ERROR_NONE, error); + for (int i = 0; i < output_count; i++) { + error = tdm_helper_capture_output(outputs[i], surface, 0, 0, 255, 255, capture_handler, &capture_handler_is_called); + ASSERT_EQ(TDM_ERROR_NONE, error); + } +} + +/* int tdm_helper_output_commit_per_vblank_enabled(tdm_output *output); */ +TEST_F(TDMHelperOutput, CommitPerVblankEnabledFailNull) +{ + int state; + state = tdm_helper_output_commit_per_vblank_enabled(NULL); + ASSERT_EQ(-1, state); +} + +TEST_F(TDMHelperOutput, CommitPerVblankEnabledSuccessful) +{ + int state; + + for (int i = 0; i < output_count; i++) { + state = tdm_helper_output_commit_per_vblank_enabled(outputs[i]); + ASSERT_EQ(1, state); + } +} + -- 2.7.4 From 8f7fc2e6579e305872588ecf4f84026fedf7f05b Mon Sep 17 00:00:00 2001 From: Roman Marchenko Date: Thu, 23 Nov 2017 19:04:23 +0200 Subject: [PATCH 08/16] add excluding coverage comments for tdm_helper.c add excluding coverage comments for tdm_helper.c for folowing code: - inner function; - deprecated function; Change-Id: I9b4fb790bd3576fc0bc6a5e76579f74fbb817105 Signed-off-by: Roman Marchenko --- src/tdm_helper.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/tdm_helper.c b/src/tdm_helper.c index bcd7aec..74d8bb5 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -207,6 +207,7 @@ _tdm_helper_dump_png(const char *file, const void *data, int width, fclose(fp); } +/* LCOV_EXCL_START */ INTERN char * tdm_helper_dump_make_directory(const char *path, char *reply, int *len) { @@ -272,6 +273,7 @@ tdm_helper_dump_buffer_str(tbm_surface_h buffer, char *dir, char *str) tdm_helper_dump_buffer(buffer, file); } +/* LCOV_EXCL_STOP */ EXTERN void tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file) @@ -578,6 +580,7 @@ unmap_srcbuf: return ret; } +/* LCOV_EXCL_START */ EXTERN int tdm_helper_get_fd(const char *env) { @@ -599,6 +602,7 @@ tdm_helper_set_fd(const char *env, int fd) tbm_drm_helper_set_tbm_master_fd(fd); } +/* LCOV_EXCL_STOP */ EXTERN void tdm_helper_dump_start(char *dumppath, int *count) @@ -621,6 +625,7 @@ tdm_helper_dump_stop(void) TDM_DBG("tdm_helper_dump stop."); } +/* LCOV_EXCL_START */ static tdm_error _tdm_helper_buffer_convert(tbm_surface_h srcbuf, tbm_surface_h dstbuf, int dx, int dy, int dw, int dh, int count) @@ -708,6 +713,8 @@ cant_convert: return TDM_ERROR_OPERATION_FAILED; } +/* LCOV_EXCL_STOP */ + EXTERN tdm_error tdm_helper_capture_output(tdm_output *output, tbm_surface_h dst_buffer, @@ -1061,6 +1068,7 @@ tdm_helper_get_display_information(tdm_display *dpy, char *reply, int *len) TDM_SNPRINTF(reply, len, "\n"); } +/* LCOV_EXCL_START */ EXTERN int tdm_helper_commit_per_vblank_enabled(tdm_display *dpy) { @@ -1068,6 +1076,7 @@ tdm_helper_commit_per_vblank_enabled(tdm_display *dpy) return 0; } +/* LCOV_EXCL_STOP */ EXTERN int tdm_helper_output_commit_per_vblank_enabled(tdm_output *output) -- 2.7.4 From a2e571d41a5c41c16165ca4b0bab9139d5c2e39a Mon Sep 17 00:00:00 2001 From: Andrii Sokolenko Date: Fri, 24 Nov 2017 10:45:59 +0200 Subject: [PATCH 09/16] utest: Fix warning of incorrect 64bits type casting Change-Id: Ic0ab8db296a8295425da1ffc44d1bced023daea1 Signed-off-by: Andrii Sokolenko --- utests/src/ut_tdm_output.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index effb32f..be7d0b3 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -49,7 +49,7 @@ protected: tdm_value value, void *u_data) { - if ( ((int) u_data) < -100) { + if ( ((intptr_t) u_data) < -100) { TDMOutput::handle_call++; } } @@ -375,7 +375,7 @@ TEST_F(TDMOutput, OutputAddChangeHandlerSuccessfulFewFuncs) if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) continue; checked = true; - for (int k = 0; k < 20; k++) { + for (intptr_t k = 0; k < 20; k++) { ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_add_change_handler(output, tdm_output_change_handler_test_func, (void *) (-101-k))); @@ -463,7 +463,7 @@ TEST_F(TDMOutput, OutputRemoveChangeHandlerSuccessfulFewFuncs) if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) continue; checked = true; - for (int k = 0; k < 20; k++) { + for (intptr_t k = 0; k < 20; k++) { ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_add_change_handler(output, tdm_output_change_handler_test_func, (void *) (-101-k))); @@ -472,7 +472,7 @@ TEST_F(TDMOutput, OutputRemoveChangeHandlerSuccessfulFewFuncs) ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF)); ASSERT_GT(handle_call, 20); handle_call = 0; - for (int k = 0; k < 20; k++) { + for (intptr_t k = 0; k < 20; k++) { tdm_output_remove_change_handler(output, tdm_output_change_handler_test_func, (void *) (-101-k)); } ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON)); -- 2.7.4 From 6fc6a8ec3d14782e56dfbdf6b96acdf909fe4732 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Sun, 26 Nov 2017 13:43:10 +0900 Subject: [PATCH 10/16] package version up to 1.9.0 Change-Id: Iaa50a2ba6a8a4fc5b45ea920be480ed7d1a4a657 --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index f83d628..d68ef56 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -1,7 +1,7 @@ %define UTEST_PACKAGE 1 Name: libtdm -Version: 1.8.4 +Version: 1.9.0 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From bed36e3c270d7b5610425283d1eee779072b8ca9 Mon Sep 17 00:00:00 2001 From: Konstantin Drabeniuk Date: Fri, 24 Nov 2017 12:44:14 +0200 Subject: [PATCH 11/16] add excluding coverage comments for tdm_monitor_server.c and tdm_output.c add excluding coverage comments for tdm_monitor_server.c for all file. add excluding coverage comments for tdm_output.c for folowing code: - dump; - calloc fail; - fail if the backend's function don't exist; - fail in the backend's function - tdm_output_set_dpms_async() - fail if there is not capability; Change-Id: I7541c992ddc2f9ea5bb18ab77e97de2a3ed2cf28 Signed-off-by: Konstantin Drabeniuk --- src/tdm_monitor_server.c | 2 ++ src/tdm_output.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/src/tdm_monitor_server.c b/src/tdm_monitor_server.c index 0d92cef..ea56a8b 100644 --- a/src/tdm_monitor_server.c +++ b/src/tdm_monitor_server.c @@ -45,6 +45,7 @@ #define TDM_DBG_SERVER_ARGS_MAX 32 +/* LCOV_EXCL_START */ static void _tdm_monitor_server_usage(char *app_name, char *reply, int *len); static void @@ -702,3 +703,4 @@ tdm_monitor_server_command(tdm_display *dpy, const char *options, char *reply, i _tdm_monitor_server_command(pid, cwd, dpy, argc, argv, reply, len); } +/* LCOV_EXCL_STOP */ diff --git a/src/tdm_output.c b/src/tdm_output.c index 078946a..855c352 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -127,6 +127,7 @@ tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status) return ret; } +/* LCOV_EXCL_START */ static void _tdm_output_update(tdm_output *output_backend, void *user_data) { @@ -192,6 +193,7 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, TDM_OUTPUT_CHANGE_CONNECTION, value, 0); } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_output_add_change_handler(tdm_output *output, @@ -207,9 +209,11 @@ tdm_output_add_change_handler(tdm_output *output, change_handler = calloc(1, sizeof(tdm_private_change_handler)); if (!change_handler) { + /* LCOV_EXCL_START */ TDM_ERR("failed: alloc memory"); _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ } change_handler->private_output = private_output; @@ -536,9 +540,11 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value) func_output = &private_display->func_output; if (!func_output->output_set_property) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } ret = func_output->output_set_property(private_output->output_backend, id, @@ -562,9 +568,11 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value) func_output = &private_display->func_output; if (!func_output->output_get_property) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } ret = func_output->output_get_property(private_output->output_backend, id, @@ -734,8 +742,10 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync, interval = 1; if (!func_output->output_wait_vblank) { + /* LCOV_EXCL_START */ TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } if (!private_output->regist_vblank_cb) { @@ -746,8 +756,10 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync, vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler)); if (!vblank_handler) { + /* LCOV_EXCL_START */ TDM_ERR("failed: alloc memory"); return TDM_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ } if (tdm_debug_module & TDM_DEBUG_COMMIT) @@ -785,11 +797,13 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync, return ret; wait_failed: + /* LCOV_EXCL_START */ if (vblank_handler) { LIST_DEL(&vblank_handler->link); free(vblank_handler); } return ret; + /* LCOV_EXCL_STOP */ } EXTERN tdm_error @@ -814,6 +828,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, return ret; } +/* LCOV_EXCL_START */ EXTERN tdm_error tdm_output_wait_vblank_add_front(tdm_output *output, int interval, int sync, tdm_output_vblank_handler func, void *user_data) @@ -835,6 +850,7 @@ tdm_output_wait_vblank_add_front(tdm_output *output, int interval, int sync, return ret; } +/* LCOV_EXCL_STOP */ INTERN void tdm_output_remove_vblank_handler_internal(tdm_output *output, tdm_output_vblank_handler func, void *user_data) @@ -915,8 +931,10 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl func_output = &private_display->func_output; if (!func_output->output_commit) { + /* LCOV_EXCL_START */ TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } ret = tdm_output_get_dpms_internal(output, &dpms_value); @@ -933,8 +951,10 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl output_commit_handler = calloc(1, sizeof(tdm_private_output_commit_handler)); if (!output_commit_handler) { + /* LCOV_EXCL_START */ TDM_ERR("failed: alloc memory"); return TDM_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ } LIST_ADDTAIL(&output_commit_handler->link, &private_output->output_commit_handler_list); @@ -977,11 +997,13 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl return ret; commit_failed: + /* LCOV_EXCL_START */ if (output_commit_handler) { LIST_DEL(&output_commit_handler->link); free(output_commit_handler); } return ret; + /* LCOV_EXCL_STOP */ } EXTERN tdm_error @@ -1043,9 +1065,11 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode) func_output = &private_display->func_output; if (!func_output->output_set_mode) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } ret = func_output->output_set_mode(private_output->output_backend, mode); @@ -1087,6 +1111,7 @@ _tdm_output_dpms_changed_timeout(void *user_data) return TDM_ERROR_NONE; } +/* LCOV_EXCL_START */ INTERN void tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data) { @@ -1134,6 +1159,7 @@ tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_ TDM_OUTPUT_CHANGE_DPMS, value, 0); } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) @@ -1168,9 +1194,11 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) tdm_event_loop_add_timer_handler(private_output->private_display, _tdm_output_dpms_changed_timeout, private_output, NULL); if (!private_output->dpms_changed_timer) { + /* LCOV_EXCL_START */ TDM_ERR("can't create dpms timer!!"); _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ } } @@ -1181,9 +1209,11 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) if (func_output->output_set_dpms) ret = func_output->output_set_dpms(private_output->output_backend, dpms_value); else { + /* LCOV_EXCL_START */ ret = TDM_ERROR_NONE; TDM_WRN("not implemented!!"); goto done; + /* LCOV_EXCL_STOP */ } done: @@ -1211,6 +1241,7 @@ done: return ret; } +/* LCOV_EXCL_START */ EXTERN tdm_error tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value) { @@ -1275,6 +1306,7 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value) return ret; } +/* LCOV_EXCL_STOP */ INTERN tdm_error tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) @@ -1297,15 +1329,19 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) func_output = &private_display->func_output; if (!func_output->output_get_dpms) { + /* LCOV_EXCL_START */ *dpms_value = private_output->current_dpms_value; TDM_WRN("not implemented!!"); return TDM_ERROR_NONE; + /* LCOV_EXCL_STOP */ } ret = func_output->output_get_dpms(private_output->output_backend, dpms_value); if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ TDM_ERR("output_get_dpms failed"); *dpms_value = TDM_OUTPUT_DPMS_OFF; + /* LCOV_EXCL_STOP */ } /* TODO: this is ugly. But we have to check if all backends's DPMS operation has no problem. */ @@ -1363,9 +1399,11 @@ tdm_output_hwc_create_window(tdm_output *output, tdm_error *error) if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) hwc_window = (tdm_hwc_window *)tdm_hwc_window_create_internal(private_output, error); else { + /* LCOV_EXCL_START */ TDM_ERR("output(%p) not support HWC", private_output); if (error) *error = TDM_ERROR_BAD_REQUEST; + /* LCOV_EXCL_STOP */ } _pthread_mutex_unlock(&private_display->lock); @@ -1409,9 +1447,11 @@ tdm_output_hwc_validate(tdm_output *output, uint32_t *num_types) func_output = &private_display->func_output; if (!func_output->output_hwc_validate) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } ret = func_output->output_hwc_validate(private_output->output_backend, num_types); @@ -1476,16 +1516,20 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output, func_output = &private_display->func_output; if (!func_output->output_hwc_get_changed_composition_types) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } ret = func_output->output_hwc_get_changed_composition_types(private_output->output_backend, num_elements, hwc_window, composition_types); if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); return ret; + /* LCOV_EXCL_STOP */ } if (hwc_window == NULL || composition_types == NULL) { @@ -1498,11 +1542,13 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output, private_hwc_window = _tdm_output_find_private_hwc_window(private_output, hwc_window[i]); if (private_hwc_window == NULL) { + /* LCOV_EXCL_START */ TDM_ERR("failed! This should never happen!"); func_output->output_hwc_destroy_window(private_output->output_backend, hwc_window[i]); *num_elements = 0; _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OPERATION_FAILED; + /* LCOV_EXCL_STOP */ } hwc_window[i] = (tdm_hwc_window*)private_hwc_window; @@ -1531,9 +1577,11 @@ tdm_output_hwc_accept_changes(tdm_output *output) func_output = &private_display->func_output; if (!func_output->output_hwc_validate) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } ret = func_output->output_hwc_accept_changes(private_output->output_backend); @@ -1564,9 +1612,11 @@ tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error) func_output = &private_display->func_output; if (!func_output->output_hwc_get_target_buffer_queue) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return NULL; + /* LCOV_EXCL_STOP */ } queue = func_output->output_hwc_get_target_buffer_queue(private_output->output_backend, error); @@ -1576,6 +1626,7 @@ tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error) return queue; } +/* LCOV_EXCL_START */ static void _tdm_target_window_dump_buffer(tdm_private_output *private_output, tbm_surface_h buffer) { @@ -1591,6 +1642,7 @@ _tdm_target_window_dump_buffer(tdm_private_output *private_output, tbm_surface_h return; } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target_buffer, @@ -1609,24 +1661,30 @@ tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target } if (tdm_debug_dump & TDM_DUMP_FLAG_WINDOW) { + /* LCOV_EXCL_START */ char str[TDM_PATH_LEN]; static int i; snprintf(str, TDM_PATH_LEN, "target_window_%d_%03d", private_output->index, i++); tdm_helper_dump_buffer_str(target_buffer, tdm_debug_dump_dir, str); + /* LCOV_EXCL_STOP */ } func_output = &private_display->func_output; if (!func_output->output_hwc_set_client_target_buffer) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_ERR("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ } /* dump buffer */ if (tdm_dump_enable) + /* LCOV_EXCL_START */ _tdm_target_window_dump_buffer((tdm_private_output *)output, target_buffer); + /* LCOV_EXCL_STOP */ ret = func_output->output_hwc_set_client_target_buffer(private_output->output_backend, target_buffer, damage); -- 2.7.4 From 05519c6c5265c19f1970480a9db50e7850753596 Mon Sep 17 00:00:00 2001 From: Konstantin Drabeniuk Date: Fri, 24 Nov 2017 13:28:27 +0200 Subject: [PATCH 12/16] utest: improve the test coverage for tdm_output.c Change-Id: I71c9e30c79e5f1d98065f13149dbd1b1c3c4826a Signed-off-by: Konstantin Drabeniuk --- utests/src/ut_tdm_hwc_window.cpp | 115 +++++++- utests/src/ut_tdm_output.cpp | 576 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 675 insertions(+), 16 deletions(-) diff --git a/utests/src/ut_tdm_hwc_window.cpp b/utests/src/ut_tdm_hwc_window.cpp index d6fb90c..f4c33a5 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/utests/src/ut_tdm_hwc_window.cpp @@ -32,8 +32,9 @@ #include "ut_common.h" #include "stdint.h" -extern "C" { #include "tdm.h" +#include "tdm_backend.h" +extern "C" { #include "tbm_bufmgr.h" #include "tbm_drm_helper.h" } @@ -52,7 +53,7 @@ protected: { setenv("TDM_DEBUG_MODULE", "all", 1); setenv("TDM_DEBUG", "1", 1); - setenv("TDM_THREAD", "0", 1); + setenv("TDM_THREAD", "1", 1); setenv("TDM_COMMIT_PER_VBLANK", "1", 1); setenv("TDM_DLOG", "1", 1); setenv("TDM_HWC", "1", 1); @@ -177,7 +178,14 @@ protected: UnsetEnv(); } +}; +class TDMOutputHwcWithoutHwcCap : public TDMOutputHwc { + void SetEnv() + { + TDMOutputHwc::SetEnv(); + setenv("TDM_HWC", "0", 1); + } }; #define HWC_WIN_NUM 5 @@ -284,6 +292,19 @@ TEST_F(TDMOutputHwc, SetClientTargetBufferFailNullOutput) ASSERT_NE(TDM_ERROR_NONE, error); } +TEST_F(TDMOutputHwcWithoutHwcCap, SetClientTargetBufferFailNoHwc) +{ + tdm_hwc_region damage; + + for (int i = 0; i < output_count; i++) { + tbm_surface_h target_buff = CreateBufferForOutput(i); + ASSERT_NE(NULL, target_buff); + error = tdm_output_hwc_set_client_target_buffer(outputs[i], target_buff, damage); + tbm_surface_internal_destroy(target_buff); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + TEST_F(TDMOutputHwc, SetClientTargetBufferSuccessfulSetBuff) { tdm_hwc_region damage; @@ -331,6 +352,17 @@ TEST_F(TDMOutputHwc, GetTargetBufferQueueFailNullOutput) ASSERT_EQ(NULL, queue); } +TEST_F(TDMOutputHwcWithoutHwcCap, GetTargetBufferQueueFainNoHwc) +{ + tbm_surface_queue_h queue = NULL; + + for (int i = 0; i < output_count; i++) { + queue = tdm_output_hwc_get_target_buffer_queue(outputs[i], &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, queue); + } +} + TEST_F(TDMOutputHwc, GetTargetBufferQueueSuccessful) { tbm_surface_queue_h queue = NULL; @@ -639,6 +671,16 @@ TEST_F(TDMOutputHwc, ValidateFailNull) } } +TEST_F(TDMOutputHwcWithoutHwcCap, ValidateFailNoHwc) +{ + uint32_t num_types; + + for (int i = 0; i < output_count; i++) { + error = tdm_output_hwc_validate(outputs[i], &num_types); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + TEST_F(TDMOutputHwc, ValidateSuccessful) { uint32_t num_types; @@ -657,7 +699,6 @@ TEST_F(TDMOutputHwc, ValidateSuccessful) uint32_t *num_elements, tdm_hwc_window **hwc_window, tdm_hwc_window_composition *composition_types); */ -/* tdm_error tdm_output_hwc_accept_changes(tdm_output *output); */ TEST_F(TDMOutputHwc, GetChangedCompositionTypesFailNull) { uint32_t num_elements; @@ -671,6 +712,16 @@ TEST_F(TDMOutputHwc, GetChangedCompositionTypesFailNull) } } +TEST_F(TDMOutputHwcWithoutHwcCap, GetChangedCompositionTypesFailNoHwc) +{ + uint32_t get_num = 10; + + for (int i = 0; i < output_count; i++) { + error = tdm_output_hwc_get_changed_composition_types(outputs[i], &get_num, NULL, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + TEST_F(TDMHwcWindow, GetChangedCompositionTypesSuccessful) { uint32_t validate_num; @@ -701,6 +752,7 @@ TEST_F(TDMHwcWindow, GetChangedCompositionTypesSuccessful) free(hwc_wnds); free(composition_types); + ASSERT_EQ(TDM_ERROR_NONE, error); } else { error = tdm_output_hwc_get_changed_composition_types(outputs[i], &get_num, NULL, NULL); @@ -709,8 +761,48 @@ TEST_F(TDMHwcWindow, GetChangedCompositionTypesSuccessful) } } +/* tdm_error tdm_output_hwc_accept_changes(tdm_output *output); */ + +TEST_F(TDMOutputHwc, AcceptChangesFailNull) +{ + error = tdm_output_hwc_accept_changes(NULL); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_F(TDMOutputHwcWithoutHwcCap, AcceptChangesFailNoHwc) +{ + for (int i = 0; i < output_count; i++) { + error = tdm_output_hwc_accept_changes(outputs[i]); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +TEST_F(TDMHwcWindow, AcceptChangesSuccessful) +{ + uint32_t validate_num; + + for (int i = 0; i < hwc_count; i++) { + error = tdm_hwc_window_set_composition_type(hwc_wins[i], TDM_COMPOSITION_DEVICE); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + + for (int i = 0; i < output_count; i++) { + if (IsHwcEnable(i)) { + error = tdm_output_hwc_validate(outputs[i], &validate_num); + ASSERT_EQ(TDM_ERROR_NONE, error); + + if (validate_num > 0) { + error = tdm_output_hwc_accept_changes(outputs[i]); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + } + } +} + +static int need_validate_handler_is_called = 0; static void need_validate_handler(tdm_output *output) { + need_validate_handler_is_called = 1; } /* tdm_error tdm_output_hwc_set_need_validate_handler(tdm_output *output, tdm_output_need_validate_handler hndl); */ @@ -723,6 +815,15 @@ TEST_F(TDMOutputHwc, SetNeedValidateHandlerFailNull) ASSERT_NE(TDM_ERROR_NONE, error); } + +TEST_F(TDMOutputHwcWithoutHwcCap, SetNeedValidateHandlerFailNoHwc) +{ + for (int i = 0; i < output_count; i++) { + error = tdm_output_hwc_set_need_validate_handler(outputs[i], &need_validate_handler); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + TEST_F(TDMOutputHwc, SetNeedValidateHandlerSuccessful) { for (int i = 0; i < output_count; i++) { @@ -731,6 +832,14 @@ TEST_F(TDMOutputHwc, SetNeedValidateHandlerSuccessful) error = tdm_output_hwc_set_need_validate_handler(outputs[i], &need_validate_handler); ASSERT_EQ(TDM_ERROR_NONE, error); + error = tdm_backend_trigger_need_validate_event(outputs[i]); + ASSERT_EQ(TDM_ERROR_NONE, error); + + error = tdm_display_handle_events(dpy); + ASSERT_EQ(TDM_ERROR_NONE, error); + + ASSERT_EQ(1, need_validate_handler_is_called); + /* test: second isn't allowed*/ error = tdm_output_hwc_set_need_validate_handler(outputs[i], &need_validate_handler); ASSERT_NE(TDM_ERROR_NONE, error); diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index be7d0b3..71c7b55 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -31,11 +31,15 @@ #include "gtest/gtest.h" #include "ut_common.h" #include -extern "C" { #include "tdm.h" +extern "C" { #include "tbm_bufmgr.h" #include "tbm_drm_helper.h" } +#include +#include +#include +#include class TDMOutput : public ::testing::Test { protected: @@ -53,13 +57,31 @@ protected: TDMOutput::handle_call++; } } - void SetUp(void) + virtual void SetEnvs() { + setenv("TDM_DEBUG_MODULE", "all", 1); + setenv("TDM_DEBUG", "1", 1); setenv("TDM_DLOG", "1", 1); setenv("XDG_RUNTIME_DIR", ".", 1); setenv("TBM_DLOG", "1", 1); setenv("TBM_DISPLAY_SERVER", "1", 1); setenv("TDM_COMMIT_PER_VBLANK", "0", 1); + } + + virtual void UnsetEnvs() + { + unsetenv("TDM_DEBUG_MODULE"); + unsetenv("TDM_DEBUG"); + unsetenv("TDM_DLOG"); + unsetenv("XDG_RUNTIME_DIR"); + unsetenv("TBM_DLOG"); + unsetenv("TBM_DISPLAY_SERVER"); + unsetenv("TDM_COMMIT_PER_VBLANK"); + } + + void SetUp(void) + { + SetEnvs(); tdm_error error = TDM_ERROR_NONE; dpy = tdm_display_init(&error); @@ -97,22 +119,76 @@ protected: exit(1); close(tbm_fd); } - unsetenv("TDM_DLOG"); - unsetenv("XDG_RUNTIME_DIR"); - unsetenv("TBM_DLOG"); - unsetenv("TBM_DISPLAY_SERVER"); - unsetenv("TDM_COMMIT_PER_VBLANK"); + + UnsetEnvs(); + } +}; + +class TDMOutputHWC : public TDMOutput { + void SetEnvs(void) + { + TDMOutput::SetEnvs(); + setenv("TDM_HWC", "1", 1); + } + void UnsetEnvs(void) + { + TDMOutput::UnsetEnvs(); + unsetenv("TDM_HWC"); + } +}; + +class TDMOutputThread : public TDMOutput { + void SetEnvs(void) + { + + TDMOutput::SetEnvs(); + setenv("TDM_THREAD", "1", 1); + } + void UnsetEnvs(void) + { + TDMOutput::UnsetEnvs(); + unsetenv("TDM_THREAD"); } }; class TDMOutputCommit : public TDMOutput { +private: + int epFd = -1; + int timerFd = -1; + int tdmFd = -1; + static const int timeLimitSec = 1; + static const int timeLimitNsec = 0; protected: int conn_output_count = 0; tdm_output ** connected_output_array = NULL; const tdm_output_mode** preferred_mode = NULL; bool has_output = false; + std::vector> layers_array; + std::vector buffers; + static unsigned int utOutputCommitHandlerCounter; + static void UtOutputCommitHandler(tdm_output *output, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, + void *user_data) + { + utOutputCommitHandlerCounter++; + } + + static unsigned int utOutputVblankHandlerCounter; + static void UtOutputVblankHandler(tdm_output *output, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, + void *user_data) + { + utOutputVblankHandlerCounter++; + } + friend void *UtOutputRemoveChangeHandlerSuccessfulThread(void *ptr); + void SetUp(void) { + struct epoll_event ep; + + utOutputCommitHandlerCounter = 0; + utOutputVblankHandlerCounter = 0; + ASSERT_NO_FATAL_FAILURE(TDMOutput::SetUp()); if (TDMOutput::output_count > 0) { connected_output_array = (tdm_output **) calloc(TDMOutput::output_count, sizeof(tdm_output *)); @@ -124,8 +200,10 @@ protected: for (int i = 0; i < TDMOutput::output_count; i++) { tdm_error error = TDM_ERROR_NONE; int output_modes_cnt = 0; + int layer_count = 0; const tdm_output_mode* output_modes = NULL; tdm_output * output = tdm_display_get_output(TDMOutput::dpy, i, &error); + std::vector layers; if (TDM_ERROR_NONE != error || NULL == output) continue; tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED; @@ -147,7 +225,21 @@ protected: } if (NULL == preferred_mode[conn_output_count]) continue; + + if (TDM_ERROR_NONE != tdm_output_get_layer_count(output, &layer_count)) + continue; + if (0 == layer_count) + continue; + + for (int i = 0; i < layer_count; ++i) { + tdm_layer *layer; + layer = tdm_output_get_layer(output, i, &error); + if (layer == nullptr) + continue; + layers.push_back(layer); + } connected_output_array[conn_output_count++] = output; + layers_array.push_back(layers); } #ifdef FAIL_ON_UNSUPPORTED ASSERT_GT(conn_output_count, 0); @@ -155,9 +247,37 @@ protected: if (conn_output_count > 0) has_output = true; + + epFd = epoll_create1(0); + ASSERT_TRUE(epFd != -1); + + timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK); + ASSERT_TRUE(timerFd != -1); + + memset(&ep, 0, sizeof ep); + ep.events |= EPOLLIN; + ep.data.fd = timerFd; + ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, timerFd, &ep) == 0); + + ASSERT_TRUE(tdm_display_get_fd(dpy, &tdmFd) == TDM_ERROR_NONE); + + memset(&ep, 0, sizeof ep); + ep.events |= EPOLLIN; + ep.data.fd = tdmFd; + ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, tdmFd, &ep) == 0); } void TearDown(void) { + for (size_t i = 0; i < layers_array.size(); ++i) { + for (tdm_layer *layer : layers_array[i]) { + tdm_layer_unset_buffer(layer); + } + } + + for (tbm_surface_h buffer : buffers) { + tbm_surface_destroy(buffer); + } + for (int i = 0; i < conn_output_count; i++) { EXPECT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(connected_output_array[i], TDM_OUTPUT_DPMS_OFF)); @@ -168,10 +288,141 @@ protected: free(preferred_mode); ASSERT_NO_FATAL_FAILURE(TDMOutput::TearDown()); } + + tbm_surface_h UtCreateBuffer(int width, int height, tbm_format format) + { + tbm_surface_h buffer; + + buffer = tbm_surface_internal_create_with_flags(width, height, format, TBM_BO_SCANOUT); + + if (buffer) + buffers.push_back(buffer); + + return buffer; + } + + void UtPrepareToCommit() + { + for (size_t i = 0; i < layers_array.size(); ++i) { + for (tdm_layer *layer : layers_array[i]) { + int w, h; + tdm_error error; + tdm_layer_capability lcapabilities; + tbm_surface_h buffer; + tdm_info_layer layer_info = {0}; + + w = preferred_mode[i]->hdisplay; + h = preferred_mode[i]->vdisplay; + + error = tdm_output_set_mode(connected_output_array[i], preferred_mode[i]); + ASSERT_EQ(TDM_ERROR_NONE, error); + + error = tdm_layer_get_capabilities(layer, &lcapabilities); + ASSERT_EQ(TDM_ERROR_NONE, error); + if (!(lcapabilities & TDM_LAYER_CAPABILITY_PRIMARY)) { + w = w / 2; + h = h / 2; + } + + buffer = UtCreateBuffer(w, h, TBM_FORMAT_ARGB8888); + ASSERT_NE(nullptr, buffer); + + layer_info.src_config.size.h = w; + layer_info.src_config.size.v = h; + layer_info.src_config.pos.x = 0; + layer_info.src_config.pos.y = 0; + layer_info.src_config.pos.w = w; + layer_info.src_config.pos.h = h; + layer_info.src_config.format = TBM_FORMAT_ARGB8888; + layer_info.dst_pos.x = 0; + layer_info.dst_pos.y = 0; + layer_info.dst_pos.w = w; + layer_info.dst_pos.h = h; + layer_info.transform = TDM_TRANSFORM_NORMAL; + + error = tdm_layer_set_info(layer, &layer_info); + ASSERT_EQ(TDM_ERROR_NONE, error); + + error = tdm_layer_set_buffer(layer, buffer); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + } + } + + void UtHandleEvent(unsigned int & wait_var, unsigned int num) + { + struct itimerspec its; + int count; + struct epoll_event ep_event[2]; + + if (wait_var == num) + return; + + its.it_interval.tv_sec = 0; + its.it_interval.tv_nsec = 0; + its.it_value.tv_sec = timeLimitSec; + its.it_value.tv_nsec = timeLimitNsec; + + ASSERT_TRUE(timerfd_settime(timerFd, 0, &its, NULL) == 0); + + while (1) { + count = epoll_wait(epFd, ep_event, sizeof(ep_event), -1); + ASSERT_TRUE(count >= 0); + + for (int i = 0; i < count; i++) { + if (ep_event[i].data.fd == timerFd) { + return; + } else { + ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + if (wait_var == num) + return; + } + } + } + } + + void UtHandleCommitEvent() + { + UtHandleEvent(utOutputCommitHandlerCounter, (unsigned int)conn_output_count); + } + + void UtHandleVblankEvent() + { + UtHandleEvent(utOutputVblankHandlerCounter, conn_output_count); + } +}; + +class TDMOutputCommitPerVblankEnabled : public TDMOutputCommit { + void SetEnvs(void) + { + + TDMOutputCommit::SetEnvs(); + setenv("TDM_COMMIT_PER_VBLANK", "1", 1); + } + void UnsetEnvs(void) + { + TDMOutputCommit::UnsetEnvs(); + unsetenv("TDM_COMMIT_PER_VBLANK"); + } }; +class TDMOutputCommitThread : public TDMOutputCommit { + void SetEnvs(void) + { + TDMOutputCommit::SetEnvs(); + setenv("TDM_THREAD", "1", 1); + } + + void UnsetEnvs(void) + { + TDMOutputCommit::UnsetEnvs(); + unsetenv("TDM_THREAD"); + } +}; unsigned int TDMOutput::handle_call = 0; +unsigned int TDMOutputCommit::utOutputCommitHandlerCounter = 0; +unsigned int TDMOutputCommit::utOutputVblankHandlerCounter = 0; TEST_F(TDMOutput, DisplayGetOutputSuccessful) { @@ -449,6 +700,69 @@ TEST_F(TDMOutput, OutputRemoveChangeHandlerSuccessful) } } +void *UtOutputRemoveChangeHandlerSuccessfulThread(void *ptr) +{ + TDMOutputCommitThread *FTDMOutput = (TDMOutputCommitThread *)ptr; + + bool checked = false; + for (int i = 0; i < FTDMOutput->output_count; i++) { + tdm_error error = TDM_ERROR_NONE; + tdm_output * output = tdm_display_get_output(FTDMOutput->dpy, i, &error); + if (NULL == output || TDM_ERROR_NONE != error) + return (void *)1; + tdm_output_conn_status status; + error = tdm_output_get_conn_status(output, &status); + if (TDM_ERROR_NONE != error) + return (void *)2; + if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) + continue; + checked = true; + error = tdm_output_add_change_handler(output, + FTDMOutput->tdm_output_change_handler_test_func, + (void *) -101); + if (TDM_ERROR_NONE != error) + return (void *)3; + error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON); + if (TDM_ERROR_NONE != error) + return (void *)4; + error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF); + if (TDM_ERROR_NONE != error) + return (void *)5; + FTDMOutput->UtHandleEvent(FTDMOutput->handle_call, 1); + if (FTDMOutput->handle_call <= 0) + return (void *)6; + FTDMOutput->handle_call = 0; + tdm_output_remove_change_handler(output, FTDMOutput->tdm_output_change_handler_test_func, (void *) -101); + error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON); + if (TDM_ERROR_NONE != error) + return (void *)7; + error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF); + if (TDM_ERROR_NONE != error) + return (void *)8; + FTDMOutput->UtHandleEvent(FTDMOutput->handle_call, 1); + if (FTDMOutput->handle_call != 0) + return (void *)9; + } + if (false == checked) { + return (void *)10; + } + + return nullptr; +} + +TEST_F(TDMOutputCommitThread, OutputRemoveChangeHandlerSuccessfulThread) +{ + SKIP_FLAG(has_output); + pthread_t thread = 0; + int *status = nullptr; + + ASSERT_FALSE(pthread_create(&thread, NULL, UtOutputRemoveChangeHandlerSuccessfulThread, this)); + + ASSERT_FALSE(pthread_join(thread, (void **)&status)); + + ASSERT_EQ(nullptr, status); +} + TEST_F(TDMOutput, OutputRemoveChangeHandlerSuccessfulFewFuncs) { SKIP_FLAG(has_output); @@ -561,6 +875,33 @@ TEST_F(TDMOutput, OutputGetLayerCountSuccessful) } } +TEST_F(TDMOutputHWC, OutputGetLayerCountFailHWC) +{ + SKIP_FLAG(has_output); + for (int i = 0; i < output_count; i++) { + tdm_error error = TDM_ERROR_NONE; + int count = -42; + tdm_output * output = tdm_display_get_output(dpy, i, &error); + ASSERT_FALSE(NULL == output); + ASSERT_TRUE(TDM_ERROR_NONE == error); + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_get_layer_count(output, &count)); + } +} + +TEST_F(TDMOutputHWC, OutputGetLayerFailHWC) +{ + SKIP_FLAG(has_output); + + for (int i = 0; i < output_count; i++) { + tdm_error error = TDM_ERROR_NONE; + tdm_output * output = tdm_display_get_output(dpy, i, &error); + ASSERT_FALSE(NULL == output); + ASSERT_TRUE(TDM_ERROR_NONE == error); + ASSERT_TRUE(nullptr == tdm_output_get_layer(output, 0, &error)); + ASSERT_TRUE(TDM_ERROR_NONE != error); + } +} + TEST_F(TDMOutput, OutputGetLayerCountFailNullAll) { SKIP_FLAG(has_output); @@ -906,6 +1247,40 @@ TEST_F(TDMOutput, OutputGetPipeFailOnlyOutput) exit(0);}, ::testing::ExitedWithCode(0), ""); } +TEST_F(TDMOutput, OutputGetPrimaryIndexSuccessful) +{ + SKIP_FLAG(has_output); + for (int i = 0; i < output_count; i++) { + tdm_error error = TDM_ERROR_NONE; + int primary_index = INT_MAX; + tdm_output * output = tdm_display_get_output(dpy, i, &error); + ASSERT_FALSE(NULL == output); + ASSERT_TRUE(TDM_ERROR_NONE == error); + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_primary_index(output, &primary_index)); + ASSERT_NE(primary_index, INT_MAX); + } +} + +TEST_F(TDMOutput, OutputGetPrimaryIndexFailNullAll) +{ + SKIP_FLAG(has_output); + ASSERT_EXIT({if (tdm_output_get_primary_index(NULL, NULL) == TDM_ERROR_NONE) exit(1); + exit(0);}, ::testing::ExitedWithCode(0), ""); +} + +TEST_F(TDMOutput, OutputGetPrimaryIndexFailOnlyOutput) +{ + SKIP_FLAG(has_output); + ASSERT_EXIT({for (int i = 0; i < output_count; i++) { + tdm_error error = TDM_ERROR_NONE; + tdm_output * output = tdm_display_get_output(dpy, i, &error); + if (NULL == output) exit(1); + if (TDM_ERROR_NONE != error) exit(1); + if (tdm_output_get_primary_index(output, NULL) == TDM_ERROR_NONE) exit(1); + } + exit(0);}, ::testing::ExitedWithCode(0), ""); +} + TEST_F(TDMOutput, OutputSetPropertySuccessful) { SKIP_FLAG(has_output); @@ -955,19 +1330,194 @@ TEST_F(TDMOutput, OutputGetPropertyFailNullAll) exit(0);}, ::testing::ExitedWithCode(0), ""); } +TEST_F(TDMOutputCommit, OutputCommitFailNullAll) +{ + SKIP_FLAG(has_output); + + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_commit(NULL, 0, NULL, NULL)); +} + TEST_F(TDMOutputCommit, OutputCommit) { SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); + + UtHandleCommitEvent(); + + ASSERT_EQ(conn_output_count, utOutputCommitHandlerCounter); +} + +TEST_F(TDMOutputCommitThread, OutputCommit) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); + + UtHandleCommitEvent(); + + ASSERT_EQ(conn_output_count, utOutputCommitHandlerCounter); +} + +TEST_F(TDMOutputCommitPerVblankEnabled, OutputCommitFailLayerCommit) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (size_t i = 0; i < layers_array.size(); ++i) { + for (tdm_layer *layer : layers_array[i]) { + tdm_layer_commit(layer, NULL, NULL); + } + } + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); +} + +TEST_F(TDMOutputCommitPerVblankEnabled, OutputCommitFailCommitPerVblankEnabled) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); +} + +TEST_F(TDMOutputCommit, OutputCommitFailDpmsOff) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + for (int i = 0; i < conn_output_count; i++) { - ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_mode(connected_output_array[i], preferred_mode[i])); - ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, NULL, NULL)); - /* TODO: use a commit handler instead of an usleep to wait when - * commit will be applied */ - usleep(20000); + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(connected_output_array[i], TDM_OUTPUT_DPMS_OFF)); + + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); } } -TEST_F(TDMOutputCommit, DISABLED_OutputWaitVBlank) +TEST_F(TDMOutputCommit, OutputWaitVBlankFailNullAll) +{ + SKIP_FLAG(has_output); + + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_wait_vblank(nullptr, 1, 0, nullptr, nullptr)); +} + +TEST_F(TDMOutputCommit, OutputWaitVBlankFailDpmsOff) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) { + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(connected_output_array[i], TDM_OUTPUT_DPMS_OFF)); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_wait_vblank(connected_output_array[i], 1, 0, UtOutputVblankHandler, nullptr)); + } +} + +TEST_F(TDMOutputCommit, OutputWaitVBlank) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, nullptr)); + + UtHandleCommitEvent(); + + ASSERT_EQ(conn_output_count, utOutputCommitHandlerCounter); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_wait_vblank(connected_output_array[i], 1, 0, UtOutputVblankHandler, nullptr)); + + UtHandleVblankEvent(); + + ASSERT_EQ(conn_output_count, utOutputVblankHandlerCounter); +} + +TEST_F(TDMOutputCommitThread, OutputWaitVBlank) { SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); + + UtHandleCommitEvent(); + + ASSERT_EQ(conn_output_count, utOutputCommitHandlerCounter); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_wait_vblank(connected_output_array[i], 1, 0, UtOutputVblankHandler, NULL)); + + UtHandleVblankEvent(); + + ASSERT_EQ(conn_output_count, utOutputVblankHandlerCounter); +} + +TEST_F(TDMOutputCommit, OutputRemoveVblankHandlerFailNullAll) +{ + SKIP_FLAG(has_output); + + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_remove_vblank_handler(nullptr, nullptr, nullptr)); +} + +TEST_F(TDMOutputCommitThread, OutputRemoveVblankHandlerSuccess) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); + + UtHandleCommitEvent(); + + ASSERT_EQ(conn_output_count, utOutputCommitHandlerCounter); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_wait_vblank(connected_output_array[i], 2, 0, UtOutputVblankHandler, NULL)); + + for (int i = 0; i < conn_output_count; i++) { + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_remove_vblank_handler(connected_output_array[i], UtOutputVblankHandler, NULL)); + } + + UtHandleVblankEvent(); + + ASSERT_EQ(0, utOutputVblankHandlerCounter); +} + +TEST_F(TDMOutputCommit, OutputRemoveCommitHandlerFailNullAll) +{ + SKIP_FLAG(has_output); + + ASSERT_TRUE(TDM_ERROR_NONE != tdm_output_remove_commit_handler(nullptr, nullptr, nullptr)); +} + +TEST_F(TDMOutputCommitThread, OutputRemoveCommitHandlerSuccess) +{ + SKIP_FLAG(has_output); + + ASSERT_NO_FATAL_FAILURE(UtPrepareToCommit()); + + for (int i = 0; i < conn_output_count; i++) + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_commit(connected_output_array[i], 0, UtOutputCommitHandler, NULL)); + + for (int i = 0; i < conn_output_count; i++) { + ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_remove_commit_handler(connected_output_array[i], UtOutputCommitHandler, NULL)); + } + + UtHandleCommitEvent(); } -- 2.7.4 From a542ccbcbbee734a35d5de1cd3feae2493097dda Mon Sep 17 00:00:00 2001 From: Konstantin Drabeniuk Date: Fri, 24 Nov 2017 14:43:42 +0200 Subject: [PATCH 13/16] add excluding coverage comments for tdm.c and tdm_thread.c As we test only API's funcs add excluding coverage comments for all static func in the tdm.c file. Add excluding coverage comments for tdm_thread.c for the folowing code: - TDM_THREAD_CB_OUTPUT_STATUS(it is not supported by all targets) - TDM_THREAD_CB_OUTPUT_DPMS(it is not supported by all targets) Change-Id: I8f404184774589c27f8c0dfe21574755434a75c8 Signed-off-by: Konstantin Drabeniuk --- src/tdm.c | 12 ++++++++++++ src/tdm_thread.c | 4 ++++ 2 files changed, 16 insertions(+) diff --git a/src/tdm.c b/src/tdm.c index 7c36041..418010c 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -50,6 +50,7 @@ int tdm_mutex_lock_line; const char *tdm_mutex_unlock_func; int tdm_mutex_unlock_line; +/* LCOV_EXCL_START */ static tdm_private_layer * _tdm_display_find_private_layer(tdm_private_output *private_output, tdm_layer *layer_backend) @@ -652,6 +653,7 @@ failed_update: _tdm_display_destroy_private_display(private_display); return ret; } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_display_update(tdm_display *dpy) @@ -681,6 +683,7 @@ int tdm_debug_dump; static tdm_private_display *g_private_display; static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER; +/* LCOV_EXCL_START */ static tdm_error _tdm_display_check_module(tdm_backend_module *module) { @@ -909,6 +912,7 @@ _tdm_display_unload_module(tdm_private_display *private_display) private_display->module_data = NULL; private_display->module = NULL; } +/* LCOV_EXCL_STOP */ EXTERN tdm_display * tdm_display_init(tdm_error *error) @@ -932,9 +936,11 @@ tdm_display_init(tdm_error *error) private_display = calloc(1, sizeof(tdm_private_display)); if (!private_display) { + /* LCOV_EXCL_START */ ret = TDM_ERROR_OUT_OF_MEMORY; TDM_ERR("'private_display != NULL' failed"); goto failed_alloc; + /* LCOV_EXCL_STOP */ } str = getenv("TDM_DEBUG_MODULE"); @@ -950,9 +956,11 @@ tdm_display_init(tdm_error *error) tdm_display_enable_path(str); if (pthread_mutex_init(&private_display->lock, NULL)) { + /* LCOV_EXCL_START */ ret = TDM_ERROR_OPERATION_FAILED; TDM_ERR("mutex init failed: %m"); goto failed_mutex_init; + /* LCOV_EXCL_STOP */ } _pthread_mutex_lock(&private_display->lock); @@ -1043,6 +1051,7 @@ tdm_display_init(tdm_error *error) return (tdm_display *)private_display; +/* LCOV_EXCL_START */ failed_update: _tdm_display_unload_module(private_display); failed_load: @@ -1058,6 +1067,7 @@ failed_alloc: *error = ret; pthread_mutex_unlock(&gLock); return NULL; +/* LCOV_EXCL_STOP */ } EXTERN void @@ -1109,6 +1119,7 @@ tdm_display_deinit(tdm_display *dpy) TDM_INFO("done"); } +/* LCOV_EXCL_START */ INTERN int tdm_display_check_module_abi(tdm_private_display *private_display, int abimaj, int abimin) { @@ -1359,3 +1370,4 @@ tdm_display_enable_fps(tdm_private_display *private_display, int enable) return TDM_ERROR_NONE; } +/* LCOV_EXCL_STOP */ diff --git a/src/tdm_thread.c b/src/tdm_thread.c index 8f624e1..ed5d049 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -307,6 +307,7 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) break; } case TDM_THREAD_CB_OUTPUT_STATUS: { + /* LCOV_EXCL_START */ tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status*)base; tdm_output *output_backend = tdm_display_find_output_stamp(private_loop->dpy, output_status->output_stamp); @@ -317,8 +318,10 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) tdm_output_cb_status(output_backend, output_status->status, output_status->user_data); break; + /* LCOV_EXCL_STOP */ } case TDM_THREAD_CB_OUTPUT_DPMS: { + /* LCOV_EXCL_START */ tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms*)base; tdm_output *output_backend = tdm_display_find_output_stamp(private_loop->dpy, output_dpms->output_stamp); @@ -328,6 +331,7 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) } tdm_output_cb_dpms(output_backend, output_dpms->dpms, output_dpms->user_data); break; + /* LCOV_EXCL_STOP */ } case TDM_THREAD_CB_PP_DONE: { tdm_thread_cb_pp_done *pp_done = (tdm_thread_cb_pp_done*)base; -- 2.7.4 From c82ff146433678e371da26fcf96ab8b613f1a7a1 Mon Sep 17 00:00:00 2001 From: Konstantin Drabeniuk Date: Fri, 24 Nov 2017 15:19:45 +0200 Subject: [PATCH 14/16] add excluding coverage comments for tdm_vblank.c add excluding coverage comments for tdm_vblank.c for the folowing code: - _tdm_vblank_cb_output_change; - pthread's fail; - calloc's fail; - tdm_event_loop_source_timer_update() func's fail; - _tdm_vblank_sw_timer_update() func's fail; - funcs for tdm_monitor. Change-Id: I67a22c38fd1ed19fde6ebf12a08681c60554f16c Signed-off-by: Konstantin Drabeniuk --- src/tdm_vblank.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/tdm_vblank.c b/src/tdm_vblank.c index 462eaf5..39eeca6 100644 --- a/src/tdm_vblank.c +++ b/src/tdm_vblank.c @@ -352,6 +352,7 @@ _tdm_vblank_update_output_info(tdm_private_vblank *private_vblank) private_vblank->vrefresh, private_vblank->fps, private_vblank->fps_changeable); } +/* LCOV_EXCL_START */ static void _tdm_vblank_cb_output_change(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data) @@ -388,6 +389,7 @@ _tdm_vblank_cb_output_change(tdm_output *output, tdm_output_change_type type, break; } } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_vblank_set_client_vblank_fps(unsigned int pid, const char *name, unsigned int fps) @@ -470,10 +472,12 @@ tdm_vblank_create(tdm_display *dpy, tdm_output *output, tdm_error *error) if (!vblank_list_inited) { if (pthread_mutex_init(&valid_list_lock, NULL)) { + /* LCOV_EXCL_START */ TDM_ERR("mutex init failed: %m"); if (error) *error = TDM_ERROR_OPERATION_FAILED; return NULL; + /* LCOV_EXCL_STOP */ } LIST_INITHEAD(&valid_vblank_list); LIST_INITHEAD(&valid_wait_list); @@ -482,10 +486,12 @@ tdm_vblank_create(tdm_display *dpy, tdm_output *output, tdm_error *error) private_vblank = calloc(1, sizeof * private_vblank); if (!private_vblank) { + /* LCOV_EXCL_START */ if (error) *error = TDM_ERROR_OUT_OF_MEMORY; VER("alloc failed"); return NULL; + /* LCOV_EXCL_STOP */ } tdm_output_add_change_handler(output, _tdm_vblank_cb_output_change, private_vblank); @@ -740,9 +746,11 @@ _tdm_vblank_sw_timer_update(tdm_private_vblank *private_vblank) ret = tdm_event_loop_source_timer_update(private_vblank->SW_timer, ms_delay); if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ tdm_display_unlock(private_vblank->dpy); VER("couldn't update timer"); return ret; + /* LCOV_EXCL_STOP */ } tdm_display_unlock(private_vblank->dpy); @@ -1038,9 +1046,11 @@ _tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info) ret = _tdm_vblank_sw_timer_update(private_vblank); if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ LIST_DEL(&wait_info->link); VER("couldn't update sw timer"); return ret; + /* LCOV_EXCL_STOP */ } return TDM_ERROR_NONE; @@ -1079,8 +1089,10 @@ tdm_vblank_wait(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec, wait_info = calloc(1, sizeof * wait_info); if (!wait_info) { + /* LCOV_EXCL_START */ VER("alloc failed"); return TDM_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ } /* set request time to current time if 0. This function seems to be called in server side. */ @@ -1139,6 +1151,7 @@ tdm_vblank_wait(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec, } if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ LIST_DEL(&wait_info->link); _tdm_vblank_valid_list_del(&wait_info->valid_link); @@ -1148,6 +1161,7 @@ tdm_vblank_wait(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec, free(wait_info); return ret; + /* LCOV_EXCL_STOP */ } return TDM_ERROR_NONE; @@ -1204,6 +1218,7 @@ tdm_vblank_wait_seq(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_u return tdm_vblank_wait(vblank, req_sec, req_usec, interval, func, user_data); } +/* LCOV_EXCL_START */ INTERN tdm_error tdm_vblank_set_add_front(tdm_vblank *vblank, unsigned int add_front) { @@ -1220,6 +1235,7 @@ tdm_vblank_set_add_front(tdm_vblank *vblank, unsigned int add_front) return TDM_ERROR_NONE; } +/* LCOV_EXCL_STOP */ INTERN tdm_error tdm_vblank_set_resource(tdm_vblank *vblank, struct wl_resource *resource) @@ -1244,6 +1260,7 @@ tdm_vblank_get_stamp(tdm_vblank *vblank) return private_vblank->stamp; } +/* LCOV_EXCL_START */ INTERN void tdm_vblank_get_vblank_list_information(tdm_display *dpy, char *reply, int *len) { @@ -1276,4 +1293,5 @@ tdm_vblank_get_vblank_list_information(tdm_display *dpy, char *reply, int *len) TDM_SNPRINTF(reply, len, "\n"); } +/* LCOV_EXCL_STOP */ -- 2.7.4 From e4f0f3446d7beefed462cdc445e655b418907df5 Mon Sep 17 00:00:00 2001 From: Roman Marchenko Date: Fri, 24 Nov 2017 16:28:41 +0200 Subject: [PATCH 15/16] utest: Add 10 test cases for tdm_event_loop.c Change-Id: If7286f39557388dd2fedd8f11d32fa015cb23338 Signed-off-by: Roman Marchenko --- utests/Makefile.am | 1 + utests/src/ut_tdm_event_loop.cpp | 198 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 199 insertions(+) create mode 100644 utests/src/ut_tdm_event_loop.cpp diff --git a/utests/Makefile.am b/utests/Makefile.am index eee9511..eab6e26 100644 --- a/utests/Makefile.am +++ b/utests/Makefile.am @@ -10,6 +10,7 @@ tdm_utests_SOURCES = \ src/ut_tdm_buffer.cpp \ src/ut_tdm_helper.cpp \ src/ut_tdm_layer.cpp \ + src/ut_tdm_event_loop.cpp \ src/ut_tdm_vblank.cpp tdm_utests_CXXFLAGS = \ diff --git a/utests/src/ut_tdm_event_loop.cpp b/utests/src/ut_tdm_event_loop.cpp new file mode 100644 index 0000000..62b9165 --- /dev/null +++ b/utests/src/ut_tdm_event_loop.cpp @@ -0,0 +1,198 @@ +#include "gtest/gtest.h" +#include "ut_common.h" +#include "stdint.h" +#include "fcntl.h" + +extern "C" { +#include "tdm.h" +#include "tdm_backend.h" +#include "tbm_bufmgr.h" +#include "tbm_surface.h" +#include "tbm_surface_internal.h" +#include "tbm_drm_helper.h" +} + +class TDMEventLoop: public ::testing::Test +{ +protected: + static tdm_display *dpy; + tdm_error error; + tdm_event_loop_source *loop_src; + int fd; + + static void SetEnv(void) + { + setenv("TDM_DEBUG_MODULE", "all", 1); + setenv("TDM_DEBUG", "1", 1); + setenv("TDM_THREAD", "0", 1); + setenv("XDG_RUNTIME_DIR", "/run", 1); + setenv("TBM_DISPLAY_SERVER", "1", 1); + } + + static void UnsetEnv(void) + { + unsetenv("TDM_DEBUG_MODULE"); + unsetenv("TDM_DEBUG"); + unsetenv("TDM_THREAD"); + unsetenv("XDG_RUNTIME_DIR"); + unsetenv("TBM_DISPLAY_SERVER"); + } + + static void SetUpTestCase() + { + tdm_error error; + SetEnv(); + dpy = tdm_display_init(&error); + ASSERT_NE(NULL, dpy); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + + static void TearDownTestCase() + { + tdm_display_deinit(dpy); + UnsetEnv(); + } + + int GetFd() + { + if (fd == -1) + fd = tbm_drm_helper_get_master_fd(); + return fd; + } + + void SetUp() + { + loop_src = NULL; + fd = -1; + } + + void TearDown() + { + if (loop_src) + tdm_event_loop_source_remove(loop_src); + if (fd >= 0) + close(fd); + } +}; + +tdm_display *TDMEventLoop::dpy = NULL; + +static int handler_is_called = 0; +static tdm_error timer_handler(void *user_data) +{ + if (user_data == &handler_is_called) + handler_is_called = 1; + return TDM_ERROR_NONE; +} + +static tdm_error fd_handler(int fd, tdm_event_loop_mask mask, void *user_data) +{ + if (user_data == &handler_is_called) + handler_is_called = 1; + return TDM_ERROR_NONE; +} + +/*void tdm_event_loop_source_remove(tdm_event_loop_source *source); */ +TEST_F(TDMEventLoop, SourceRemoveFailNULL) +{ + tdm_event_loop_source_remove(NULL); +} + +/* tdm_event_loop_source* tdm_event_loop_add_timer_handler(tdm_display *dpy, + tdm_event_loop_timer_handler func, + void *user_data, tdm_error *error); */ +TEST_F(TDMEventLoop, AddTimerHandlerFailNULL) +{ + loop_src = tdm_event_loop_add_timer_handler(NULL, timer_handler, &handler_is_called, &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, loop_src); + + loop_src = tdm_event_loop_add_timer_handler(dpy, NULL, &handler_is_called, &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, loop_src); + + loop_src = tdm_event_loop_add_timer_handler(dpy, NULL, &handler_is_called, NULL); + ASSERT_EQ(NULL, loop_src); +} + +TEST_F(TDMEventLoop, AddTimerHandlerSuccessful) +{ + loop_src = tdm_event_loop_add_timer_handler(dpy, timer_handler, &handler_is_called, &error); + ASSERT_EQ(TDM_ERROR_NONE, error); + ASSERT_NE(NULL, loop_src); +} + +/* tdm_error tdm_event_loop_source_timer_update(tdm_event_loop_source *source, unsigned int ms_delay); */ +TEST_F(TDMEventLoop, SourceTimerUpdateFailNULL) +{ + error = tdm_event_loop_source_timer_update(NULL, 0); + ASSERT_NE(TDM_ERROR_NONE, error); +} +TEST_F(TDMEventLoop, SourceTimerUpdateSuccessful) +{ + loop_src = tdm_event_loop_add_timer_handler(dpy, timer_handler, &handler_is_called, &error); + ASSERT_EQ(TDM_ERROR_NONE, error); + ASSERT_NE(NULL, loop_src); + + error = tdm_event_loop_source_timer_update(loop_src, 10); + ASSERT_EQ(TDM_ERROR_NONE, error); +} + +/* tdm_event_loop_source* tdm_event_loop_add_fd_handler(tdm_display *dpy, int fd, tdm_event_loop_mask mask, + tdm_event_loop_fd_handler func, void *user_data, + tdm_error *error); */ +TEST_F(TDMEventLoop, AddFdHandlerFailNULL) +{ + loop_src = tdm_event_loop_add_fd_handler(NULL, 0, TDM_EVENT_LOOP_READABLE, + fd_handler, &handler_is_called, &error); + ASSERT_EQ(NULL, loop_src); + ASSERT_NE(TDM_ERROR_NONE, error); + + loop_src = tdm_event_loop_add_fd_handler(dpy, 0, TDM_EVENT_LOOP_READABLE, + NULL, &handler_is_called, &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, loop_src); +} + +TEST_F(TDMEventLoop, AddFdHandlerFailInvalidFd) +{ + loop_src = tdm_event_loop_add_fd_handler(dpy, -1, TDM_EVENT_LOOP_READABLE, + fd_handler, &handler_is_called, &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, loop_src); +} + +TEST_F(TDMEventLoop, AddFdHandlerSuccessful) +{ + int fd = GetFd(); + ASSERT_NE(-1, fd); + + loop_src = tdm_event_loop_add_fd_handler(dpy, fd, TDM_EVENT_LOOP_READABLE, + fd_handler, &handler_is_called, &error); + ASSERT_EQ(TDM_ERROR_NONE, error); + ASSERT_NE(NULL, loop_src); +} + +/* tdm_error tdm_event_loop_source_fd_update(tdm_event_loop_source *source, tdm_event_loop_mask mask); */ +TEST_F(TDMEventLoop, SourceFdUpdateFailNULL) +{ + error = tdm_event_loop_source_fd_update(NULL, TDM_EVENT_LOOP_READABLE); +} + +TEST_F(TDMEventLoop, SourceFdUpdateSuccessful) +{ + int fd; + tdm_event_loop_mask flag = TDM_EVENT_LOOP_WRITABLE; + + fd = GetFd(); + ASSERT_NE(-1, fd); + + loop_src = tdm_event_loop_add_fd_handler(dpy, fd, flag, + fd_handler, &handler_is_called, &error); + ASSERT_EQ(TDM_ERROR_NONE, error); + ASSERT_NE(NULL, loop_src); + + error = tdm_event_loop_source_fd_update(loop_src, TDM_EVENT_LOOP_READABLE); + ASSERT_EQ(TDM_ERROR_NONE, error); +} + -- 2.7.4 From 802f43a791f330e67fad0873b3efcd022e01dfd8 Mon Sep 17 00:00:00 2001 From: Roman Marchenko Date: Fri, 24 Nov 2017 18:00:41 +0200 Subject: [PATCH 16/16] add excluding coverage comments for tdm_event_loop.c for folowing code: - inner functions Change-Id: Ic3065fa1a0f3e81bff1332b7721d4866a2635286 Signed-off-by: Roman Marchenko --- src/tdm_event_loop.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/tdm_event_loop.c b/src/tdm_event_loop.c index 1c88685..bb0ed57 100644 --- a/src/tdm_event_loop.c +++ b/src/tdm_event_loop.c @@ -472,6 +472,7 @@ tdm_event_loop_source_remove(tdm_event_loop_source *source) free(source); } +/* LCOV_EXCL_START */ static void _trace_cb_client_destroy(struct wl_listener *listener, void *data) { @@ -658,3 +659,4 @@ tdm_event_loop_trace_enable(tdm_private_display * private_display, return TDM_ERROR_NONE; } +/* LCOV_EXCL_STOP */ -- 2.7.4